revert: restore RPM target

- Import from folder or removable drive via File menu
- MD5 checksum-based duplicate detection from audio content
- Windows drive detection with removable/fixed type labels
- Drive accessibility verification before listing
- Import files copied to _Imports/<date>/ folders
- Comprehensive logging for import debugging

.github/workflows/build-all.yml

@@ -0,0 +1,89 @@
+name: Build All Platforms
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  build-windows:
+    runs-on: [self-hosted, windows]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build Windows
+        run: npm run dist:win
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Upload Windows artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-installer
+          path: release/*.exe
+
+  build-linux:
+    runs-on: [self-hosted, linux]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build Linux
+        run: npm run dist:linux
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Upload Linux artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-packages
+          path: |
+            release/*.AppImage
+            release/*.deb
+            release/*.rpm
+
+  release:
+    needs: [build-windows, build-linux]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - name: Download Windows artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-installer
+
+      - name: Download Linux artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: linux-packages
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            *.exe
+            *.AppImage
+            *.deb
+            *.rpm
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build.yml

@@ -1,29 +0,0 @@
-name: Build/release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  release:
-    runs-on: windows-latest
-
-    steps:
-      - name: Check out Git repository
-        uses: actions/checkout@v4
-
-      - name: Install Node.js and NPM
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Build/release Electron app
-        uses: samuelmeuli/action-electron-builder@v1
-        with:
-          github_token: ${{ secrets.github_token }}
-          release: ${{ startsWith(github.ref, 'refs/tags/v') }}
-          args: --win

.gitignore

@@ -64,3 +64,4 @@ test-data/
 *.tmp
 *.temp
 .cache/
+AudioSort.code-workspace

README.md

@@ -1,7 +1,7 @@
 # AudioSort
 [![Build/release](https://github.com/litruv/AudioSort/actions/workflows/build.yml/badge.svg)](https://github.com/litruv/AudioSort/actions/workflows/build.yml)
 
-A desktop application for organizing, tagging, and managing WAV audio files with Universal Category System (UCS) support.
+A desktop application for organizing, tagging, and managing WAV audio files with Universal Category System (UCS) support, featuring advanced waveform editing and audio splitting capabilities.
 
 ![AudioSort Interface](repoimages/interface.png)
 
@@ -16,6 +16,7 @@ A desktop application for organizing, tagging, and managing WAV audio files with
 ### Powerful Search & Organization
 - Fuzzy search across filenames, tags, categories, and metadata
 - Filter by category or view untagged files
+- Quick "JUST SPLIT" filter surfaces freshly generated segments for rapid QC
 - Multi-select support for batch operations
 - Custom naming with automatic conflict resolution
 
@@ -27,27 +28,24 @@ A desktop application for organizing, tagging, and managing WAV audio files with
 
 ![Multi-file Editing](repoimages/multiediting.png)
 
+### Waveform Editor
+- Visual waveform editing with playback controls
+- Segment-based audio splitting and trimming
+- Real-time preview with zoom and pan controls
+- Export individual segments with automatic naming
+- Non-destructive editing workflow
+
+![Waveform Editor](repoimages/editor.png)
+
 ### Beautiful Interface
 - Real-time waveform visualization with dynamic color-coding based on RMS levels
+- Waveform editor for splitting and trimming audio
 - Smooth animations and polished drag-and-drop interactions
 - Responsive file list with keyboard navigation (Arrow keys, Ctrl+A)
 - Dark theme optimized for long sessions
 
 ![Smooth UI Demo](repoimages/smoothui.gif)
 
-### Smart Library Management
-- Automatic library scanning and indexing
-- MD5 checksums for duplicate detection
-- Metadata caching for instant access
-- SQLite database for fast queries and reliable storage
-
-## Technology Stack
-
-- **Frontend**: React 18, TypeScript, Vite
-- **Backend**: Electron 29, Node.js
-- **Database**: better-sqlite3 with WAL mode
-- **Audio Processing**: WaveFile, music-metadata
-- **Search**: Fuse.js for fuzzy search
 
 ## Installation
 
@@ -119,8 +117,8 @@ AudioSort/
 │   │       └── hooks/       # Custom React hooks
 │   ├── preload/           # Electron preload scripts
 │   └── shared/            # Shared types and IPC definitions
-├── data/                  # User data directory (created at runtime)
-├── UCS.csv               # Universal Category System catalog
+├── data/
+│   └── UCS.csv           # Universal Category System catalog
 └── repoimages/           # Documentation assets
 ```
 
@@ -128,22 +126,12 @@ AudioSort/
 
 ### Scripts
 ```bash
-npm run dev          # Start development server with hot reload
-npm run build        # Build renderer and main process
-npm run lint         # Type-check with TypeScript
-npm run test         # Run test suite
-npm run pack         # Package without installer
-npm run dist         # Create distributable
-npm run dist:win     # Create Windows installer
-```
-
-### Testing
-```bash
-npm test              # Run all tests
-npm run test:database # Database service tests
-npm run test:library  # Library service tests
-npm run test:search   # Search service tests
-npm run test:tag      # Tag service tests
+npm run dev      # Start development server with hot reload
+npm run build    # Build renderer and main process
+npm run lint     # Type-check with TypeScript
+npm run pack     # Package without installer
+npm run dist     # Create distributable
+npm run dist:win # Create Windows installer
 ```
 
 ## Configuration
@@ -158,4 +146,3 @@ Edit `package.json` `build` section to customize:
 ### Database Location
 User data is stored in:
 - **Windows**: `%APPDATA%/AudioSort/`
-- **Linux**: `~/.config/AudioSort/`

TEST_README.md

@@ -1,219 +0,0 @@
-# AudioSort Test Suite
-
-Comprehensive test suite for AudioSort application using real WAV files with embedded metadata.
-
-## Running Tests
-
-### Run all tests
-```powershell
-npm test
-```
-
-### Run specific test suites
-```powershell
-# Tag Service tests (metadata read/write)
-npm run test:tag
-
-# Library Service tests (scanning, organizing, file operations)
-npm run test:library
-
-# Search Service tests (fuzzy search, filters)
-node --import tsx --test src/test/SearchService.test.ts
-```
-
-### Run individual test files
-```powershell
-node --import tsx --test src/test/DatabaseService.test.ts
-node --import tsx --test src/test/TagService.test.ts
-node --import tsx --test src/test/LibraryService.test.ts
-node --import tsx --test src/test/SearchService.test.ts
-```
-
-## Test Coverage
-
-### DatabaseService Tests (20+ tests)
-- **File Management**: upsertFile, listFiles, getFileById, updateFileLocation, deleteFile
-- **Tagging Operations**: updateTagging, updateCustomName
-- **Category Management**: upsertCategory, getCategoryById, listCategories
-- **Duplicate Detection**: listDuplicateGroups by checksum
-- **Settings Persistence**: setSetting, getSettings
-- Edge cases: Missing files, null values, duplicate checksums
-
-### TagService Tests (14 tests)
-- **readMetadata**: Reading author, copyright, title, rating from WAV files
-- **writeMetadataOnly**: Writing metadata to WAV INFO chunks
-- **applyTagging**: Updating tags/categories in database and WAV files
-- Edge cases: Missing metadata, corrupted files, empty values, normalization
-
-### LibraryService Tests (20+ tests)
-- **scanLibrary**: File discovery, metadata extraction, temp file cleanup
-- **listFiles**: File listing with metadata
-- **renameFile**: File renaming on disk and in database
-- **moveFile**: Moving files between directories
-- **updateCustomName**: Custom name management
-- **updateFileMetadata**: Metadata updates without organizing
-- **readFileMetadata**: Reading embedded WAV metadata
-- **listMetadataSuggestions**: Aggregating author/copyright suggestions
-- **deleteFiles**: File deletion from disk and database
-- **cleanupTempFiles**: Orphaned temp file recovery
-
-### SearchService Tests (13 tests)
-- **search**: Fuzzy search by filename, tags, path
-- **Advanced filters**: author:, copyright: field-specific searches
-- **Metadata caching**: Performance optimization
-- **rebuildIndex**: Index updates after database changes
-- Edge cases: Empty queries, typos, no matches
-
-## Test Data
-
-Tests use the `TestWavGenerator` class to create real WAV files with:
-- Configurable duration, sample rate, bit depth
-- Embedded metadata (author, copyright, title, rating)
-- Tags and UCS categories
-- Sine wave audio data (440 Hz)
-
-Example test file creation:
-```typescript
-await TestWavGenerator.writeTestWav('test.wav', {
-  duration: 1,
-  sampleRate: 44100,
-  bitDepth: 16,
-  author: 'Test Author',
-  copyright: 'Test Copyright',
-  title: 'Test Title',
-  rating: 3,
-  tags: ['test', 'audio'],
-  categories: ['AMBNatr']
-});
-```
-
-## Test Isolation
-
-Each test suite:
-1. Creates temporary database and library directories
-2. Generates fresh test WAV files
-3. Initializes services with isolated instances
-4. Cleans up all resources after tests complete
-
-Temporary files are created in `test-data/` and automatically removed.
-
-## Testing Strategy
-
-### Unit Tests
-- Test individual service methods in isolation
-- Verify correct behavior with valid inputs
-- Handle edge cases and error conditions
-
-### Integration Tests
-- Test interactions between services (LibraryService + TagService + SearchService)
-- Verify database updates reflect in search results
-- Ensure file system operations complete successfully
-
-### Real Data Tests
-- Use actual WAV files with embedded metadata
-- Test metadata round-trip (write then read)
-- Verify file integrity after operations
-
-## Extending Tests
-
-### Adding New Test Cases
-
-1. **For TagService**:
-```typescript
-it('should handle new metadata field', () => {
-  tagService.writeMetadataOnly(testFilePath, {
-    tags: [],
-    categories: [],
-    newField: 'value'
-  });
-  
-  const metadata = tagService.readMetadata(testFilePath);
-  assert.strictEqual(metadata.newField, 'value');
-});
-```
-
-2. **For LibraryService**:
-```typescript
-it('should handle new operation', async () => {
-  await libraryService.scanLibrary();
-  const files = libraryService.listFiles();
-  
-  // Perform operation
-  await libraryService.newOperation(files[0].id);
-  
-  // Verify results
-  const updated = libraryService.listFiles();
-  assert.ok(/* verification */);
-});
-```
-
-3. **For SearchService**:
-```typescript
-it('should support new filter', () => {
-  const results = searchService.search('newfilter:value');
-  
-  assert.ok(results.length > 0);
-  assert.ok(/* filter applied correctly */);
-});
-```
-
-## Troubleshooting
-
-### Tests hang or timeout
-- Check for leaked file handles (ensure database.close() in afterEach)
-- Verify temp files are being cleaned up
-- Increase test timeout if needed
-
-### File not found errors
-- Ensure library path is created before writing test files
-- Check file paths use correct separators for OS
-- Verify temp directory permissions
-
-### Metadata not persisting
-- Confirm WAV file format is correct (use WaveFile library)
-- Check INFO chunk tags are supported
-- Verify file is written to disk before reading
-
-### Search tests fail
-- Rebuild search index after database changes
-- Clear metadata cache when needed
-- Check Fuse.js scoring thresholds
-
-## Performance Considerations
-
-- Tests create real WAV files (may be slower than mocks)
-- Each test suite runs independently with fresh data
-- Cleanup operations ensure no disk space accumulation
-- Test data directory can be cleared manually if needed: `rm -rf test-data`
-
-## CI/CD Integration
-
-Tests can be run in CI/CD pipelines:
-
-```yaml
-# GitHub Actions example
-- name: Run tests
-  run: npm test
-```
-
-Tests require:
-- Node.js 18+ (for node:test runner)
-- File system write access
-- Sufficient disk space for test WAV files (~1-2 MB per test run)
-
-## Debugging Tests
-
-Enable verbose output:
-```powershell
-NODE_OPTIONS='--test-reporter=spec' npm test
-```
-
-Run specific test:
-```powershell
-node --import tsx --test --test-name-pattern="should read author" src/test/TagService.test.ts
-```
-
-Debug with inspector:
-```powershell
-node --import tsx --test --inspect-brk src/test/TagService.test.ts
-```

package.json

@@ -1,7 +1,12 @@
 {
   "name": "audio-sort",
-  "version": "0.2.0",
+  "version": "0.5.2",
   "description": "Electron audio sorting application with fuzzy search, tagging, library management, and advanced waveform editing with audio splitting capabilities for WAV files.",
+  "author": {
+    "name": "litruv",
+    "email": "litruv@example.com",
+    "url": "https://lit.ruv.wtf"
+  },
   "main": "dist/main/main/index.js",
   "type": "commonjs",
   "scripts": {
@@ -17,59 +22,74 @@
     "pack": "npm run build && electron-builder --dir",
     "dist": "npm run build && electron-builder",
     "dist:win": "npm run build && electron-builder --win",
-    "test": "node --import tsx --test src/test/DatabaseService.test.ts src/test/TagService.test.ts src/test/LibraryService.test.ts src/test/SearchService.test.ts",
-    "test:tag": "node --import tsx --test src/test/TagService.test.ts",
-    "test:library": "node --import tsx --test src/test/LibraryService.test.ts",
-    "test:database": "node --import tsx --test src/test/DatabaseService.test.ts",
-    "test:search": "node --import tsx --test src/test/SearchService.test.ts"
+    "dist:linux": "npm run build && electron-builder --linux",
+    "postinstall": "patch-package"
   },
   "dependencies": {
-    "better-sqlite3": "^11.0.0",
-    "csv-parse": "^5.5.5",
-    "fast-glob": "^3.3.2",
-    "fuse.js": "^6.6.2",
-    "music-metadata": "^10.5.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
+    "better-sqlite3": "^12.4.1",
+    "csv-parse": "^6.1.0",
+    "fast-glob": "^3.3.3",
+    "fuse.js": "^7.1.0",
+    "music-metadata": "^11.10.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "standardized-audio-context": "^25.3.77",
     "wavefile": "^11.0.0"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.8",
-    "@types/node": "^20.12.7",
-    "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0",
-    "@vitejs/plugin-react": "^4.3.3",
-    "concurrently": "^8.2.2",
-    "cross-env": "^7.0.3",
-    "electron": "^32.0.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^24.10.0",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "@vitejs/plugin-react": "^5.1.0",
+    "concurrently": "^9.2.1",
+    "cross-env": "^10.1.0",
+    "electron": "^39.1.2",
     "electron-builder": "^26.0.12",
+    "patch-package": "^8.0.1",
     "tree-kill": "^1.2.2",
-    "tsx": "^4.15.7",
-    "typescript": "^5.3.3",
-    "vite": "^5.1.6"
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.2"
   },
   "build": {
     "appId": "com.audiosort.app",
     "productName": "AudioSort",
     "files": [
       "dist/**/*",
-      "UCS.csv"
+      "data/**/*"
     ],
     "directories": {
       "output": "release"
     },
     "win": {
-      "target": ["nsis"],
+      "target": [
+        "nsis"
+      ],
       "icon": "build/icon.ico"
     },
     "nsis": {
       "oneClick": false,
       "allowToChangeInstallationDirectory": true
     },
+    "linux": {
+      "target": [
+        "AppImage",
+        "deb",
+        "rpm"
+      ],
+      "icon": "build/icon.png",
+      "category": "AudioVideo",
+      "description": "Audio sorting and management application",
+      "mimeTypes": [
+        "audio/wav",
+        "audio/x-wav"
+      ]
+    },
     "extraResources": [
       {
-        "from": "UCS.csv",
-        "to": "UCS.csv"
+        "from": "data/UCS.csv",
+        "to": "data/UCS.csv"
       }
     ]
   }

patches/better-sqlite3+12.4.1.patch

@@ -0,0 +1,13 @@
+diff --git a/node_modules/better-sqlite3/src/better_sqlite3.cpp b/node_modules/better-sqlite3/src/better_sqlite3.cpp
+index 024bb4f..28a4d55 100644
+--- a/node_modules/better-sqlite3/src/better_sqlite3.cpp
++++ b/node_modules/better-sqlite3/src/better_sqlite3.cpp
+@@ -46,7 +46,7 @@ class Backup;
+ #include "objects/statement-iterator.cpp"
+ 
+ NODE_MODULE_INIT(/* exports, context */) {
+-	v8::Isolate* isolate = context->GetIsolate();
++	v8::Isolate* isolate = v8::Isolate::GetCurrent();
+ 	v8::HandleScope scope(isolate);
+ 	Addon::ConfigureURI();
+ 

src/main/MainApp.ts

@@ -41,22 +41,28 @@ export class MainApp {
       this.searchService
     );
 
-    const catalogPath = this.resolveResourcePath('UCS.csv');
+  const catalogPath = this.resolveResourcePath(path.join('data', 'UCS.csv'));
     await this.libraryService.ensureCategoriesLoaded(catalogPath);
     await this.libraryService.scanLibrary();
 
     this.searchService.rebuildIndex();
     this.registerIpcHandlers();
-    this.createMenu();
+    await this.createMenu();
     this.createWindow();
   }
 
   /**
    * Creates the application menu.
    */
-  private createMenu(): void {
+  private async createMenu(): Promise<void> {
     const isMac = process.platform === 'darwin';
+    const drives = await this.listAvailableDrives();
     
+    const driveSubmenu: Electron.MenuItemConstructorOptions[] = drives.map((drive) => ({
+      label: drive.label,
+      click: () => this.mainWindow?.webContents.send('import-from-drive', drive.path)
+    }));
+
     const template: Electron.MenuItemConstructorOptions[] = [
       ...(isMac ? [{
         label: app.name,
@@ -79,6 +85,16 @@ export class MainApp {
       {
         label: 'File',
         submenu: [
+          {
+            label: 'Import From Folder...',
+            accelerator: isMac ? 'Cmd+Shift+I' : 'Ctrl+Shift+I',
+            click: () => this.mainWindow?.webContents.send('import-from-folder')
+          },
+          {
+            label: 'Import From Drive',
+            submenu: driveSubmenu.length > 0 ? driveSubmenu : [{ label: 'No drives available', enabled: false }]
+          },
+          { type: 'separator' as const },
           {
             label: 'Rescan Library',
             accelerator: isMac ? 'Cmd+R' : 'Ctrl+R',
@@ -132,6 +148,8 @@ export class MainApp {
     ipcMain.removeHandler(IPC_CHANNELS.settingsGet);
     ipcMain.removeHandler(IPC_CHANNELS.settingsSetLibrary);
     ipcMain.removeHandler(IPC_CHANNELS.dialogSelectLibrary);
+    ipcMain.removeHandler(IPC_CHANNELS.dialogSelectImportFolder);
+    ipcMain.removeHandler(IPC_CHANNELS.systemListDrives);
     ipcMain.removeHandler(IPC_CHANNELS.libraryScan);
     ipcMain.removeHandler(IPC_CHANNELS.libraryList);
     ipcMain.removeHandler(IPC_CHANNELS.libraryRename);
@@ -143,6 +161,7 @@ export class MainApp {
   ipcMain.removeHandler(IPC_CHANNELS.libraryUpdateMetadata);
    ipcMain.removeHandler(IPC_CHANNELS.librarySplit);
     ipcMain.removeHandler(IPC_CHANNELS.libraryWaveformPreview);
+    ipcMain.removeHandler(IPC_CHANNELS.libraryImport);
     ipcMain.removeHandler(IPC_CHANNELS.tagsUpdate);
     ipcMain.removeHandler(IPC_CHANNELS.categoriesList);
     ipcMain.removeHandler(IPC_CHANNELS.searchQuery);
@@ -215,7 +234,7 @@ export class MainApp {
     });
 
     ipcMain.handle(IPC_CHANNELS.dialogSelectLibrary, async () => {
-  const options: Electron.OpenDialogOptions = { properties: ['openDirectory'] };
+      const options: Electron.OpenDialogOptions = { properties: ['openDirectory'] };
       const targetWindow = this.mainWindow;
       const result = targetWindow
         ? await dialog.showOpenDialog(targetWindow, options)
@@ -223,8 +242,22 @@ export class MainApp {
       return result.canceled ? null : result.filePaths[0] ?? null;
     });
 
+    ipcMain.handle(IPC_CHANNELS.dialogSelectImportFolder, async () => {
+      const options: Electron.OpenDialogOptions = { properties: ['openDirectory'] };
+      const targetWindow = this.mainWindow;
+      const result = targetWindow
+        ? await dialog.showOpenDialog(targetWindow, options)
+        : await dialog.showOpenDialog(options);
+      return result.canceled ? null : result.filePaths[0] ?? null;
+    });
+
+    ipcMain.handle(IPC_CHANNELS.systemListDrives, async () => this.listAvailableDrives());
+
     ipcMain.handle(IPC_CHANNELS.libraryScan, async () => this.requireLibrary().scanLibrary());
     ipcMain.handle(IPC_CHANNELS.libraryList, async () => this.requireLibrary().listFiles());
+    ipcMain.handle(IPC_CHANNELS.libraryGetById, async (_event: IpcMainInvokeEvent, fileId: number) =>
+      this.requireLibrary().getFileById(fileId)
+    );
     ipcMain.handle(IPC_CHANNELS.libraryDuplicates, async () => this.requireLibrary().listDuplicates());
     ipcMain.handle(IPC_CHANNELS.searchQuery, async (_event: IpcMainInvokeEvent, query: string) =>
       this.requireSearch().search(query)
@@ -303,6 +336,19 @@ export class MainApp {
       ) =>
         this.requireLibrary().updateFileMetadata(fileId, metadata)
     );
+
+    ipcMain.handle(IPC_CHANNELS.libraryImport, async (_event: IpcMainInvokeEvent, payload: unknown) => {
+      if (!Array.isArray(payload)) {
+        throw new Error('Import request must provide an array of source paths.');
+      }
+      const sources = payload
+        .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+        .filter((entry) => entry.length > 0);
+      if (sources.length === 0) {
+        return { imported: [], skipped: [], failed: [] };
+      }
+      return this.requireLibrary().importExternalSources(sources);
+    });
   }
 
   /**
@@ -357,6 +403,86 @@ export class MainApp {
     return app.getAppPath();
   }
 
+  private async listAvailableDrives(): Promise<Array<{ path: string; label: string }>> {
+    if (process.platform === 'win32') {
+      try {
+        const { exec } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const execAsync = promisify(exec);
+        
+        // Query Windows Management Instrumentation for drive info
+        const { stdout } = await execAsync('wmic logicaldisk get deviceid,drivetype', { 
+          timeout: 5000,
+          windowsHide: true 
+        });
+        
+        const lines = stdout.trim().split('\n').slice(1); // Skip header
+        const drives: Array<{ path: string; type: string }> = [];
+        
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          
+          // Parse "C:            3" format (DeviceID and DriveType)
+          const match = trimmed.match(/^([A-Z]:)\s+(\d+)$/);
+          if (!match) continue;
+          
+          const [, deviceId, driveType] = match;
+          const drivePath = `${deviceId}\\`;
+          
+          // Verify drive is actually accessible before including it
+          try {
+            await fs.promises.access(drivePath);
+          } catch {
+            continue; // Skip if not accessible (unplugged/ejected)
+          }
+          
+          // DriveType: 2=Removable, 3=Local Fixed, 4=Network, 5=CD-ROM, 6=RAM Disk
+          let label = drivePath;
+          if (driveType === '2') {
+            label = `${drivePath} (Removable)`;
+          }
+          
+          drives.push({ path: drivePath, type: label });
+        }
+        
+        return drives.sort((a, b) => a.path.localeCompare(b.path)).map((d) => ({ path: d.path, label: d.type }));
+      } catch (error) {
+        console.warn('Failed to query drive types via wmic, falling back to simple enumeration', error);
+        // Fallback to basic enumeration
+        const drives: { path: string; label: string }[] = [];
+        const probes: Promise<void>[] = [];
+        for (let code = 65; code <= 90; code += 1) {
+          const letter = String.fromCharCode(code);
+          const drivePath = `${letter}:\\`;
+          const probe = fs.promises
+            .access(drivePath)
+            .then(() => {
+              drives.push({ path: drivePath, label: drivePath });
+            })
+            .catch(() => undefined);
+          probes.push(probe);
+        }
+        await Promise.all(probes);
+        return drives.sort((a, b) => a.path.localeCompare(b.path));
+      }
+    }
+
+    if (process.platform === 'darwin') {
+      try {
+        const entries = await fs.promises.readdir('/Volumes', { withFileTypes: true });
+        const volumes = entries
+          .filter((entry) => entry.isDirectory())
+          .map((entry) => ({ path: path.join('/Volumes', entry.name), label: path.join('/Volumes', entry.name) }));
+        return volumes.length > 0 ? volumes : [{ path: '/', label: '/' }];
+      } catch {
+        return [{ path: '/', label: '/' }];
+      }
+    }
+
+    return [{ path: '/', label: '/' }];
+  }
+
   private buildSearchBases(): string[] {
     const bases = new Set<string>();
     const appPath = app.getAppPath();

src/main/services/LibraryService.ts

@@ -4,7 +4,18 @@ import { createHash } from 'node:crypto';
 import path from 'node:path';
 import fg from 'fast-glob';
 import { parse } from 'csv-parse/sync';
-import { AppSettings, AudioBufferPayload, AudioFileSummary, CategoryRecord, LibraryScanSummary, SplitSegmentRequest, TagUpdatePayload } from '../../shared/models';
+import {
+  AppSettings,
+  AudioBufferPayload,
+  AudioFileSummary,
+  CategoryRecord,
+  ImportFailureEntry,
+  ImportSkipEntry,
+  LibraryImportResult,
+  LibraryScanSummary,
+  SplitSegmentRequest,
+  TagUpdatePayload
+} from '../../shared/models';
 import { DatabaseService, FileRecordInput } from './DatabaseService';
 import { SettingsService } from './SettingsService';
 import { TagService } from './TagService';
@@ -12,6 +23,15 @@ import { SearchService } from './SearchService';
 import { WaveFile } from 'wavefile';
 import { OrganizationService } from './OrganizationService';
 
+type MusicMetadataParser = (path: string, options?: { duration?: boolean }) => Promise<{
+  format: { duration?: number | null; sampleRate?: number | null; bitsPerSample?: number | null };
+  common: { comment?: unknown[]; genre?: unknown[]; subtitle?: unknown };
+}>;
+
+type MusicMetadataNamespace = Partial<{ parseFile: MusicMetadataParser }> & {
+  default?: Partial<{ parseFile: MusicMetadataParser }>;
+};
+
 interface CsvCategoryRow {
   Category: string;
   SubCategory: string;
@@ -31,6 +51,8 @@ export class LibraryService {
   private readonly organization: OrganizationService;
   private metadataSuggestionCache: { authors: Set<string> } | null = null;
   private readonly waveformPreviewCache = new Map<number, { modifiedAt: number; pointCount: number; samples: number[]; rms: number }>();
+  private offlineAudioContextCtor: (new (channelCount: number, length: number, sampleRate: number) => any) | null = null;
+  private musicMetadataParseFile: MusicMetadataParser | null = null;
   public constructor(
     private readonly database: DatabaseService,
     private readonly settings: SettingsService,
@@ -83,7 +105,7 @@ export class LibraryService {
     this.resetMetadataSuggestionsCache();
     this.waveformPreviewCache.clear();
     
-    const cleanedTempFiles = await this.cleanupTempFiles();
+  await this.cleanupTempFiles();
     const libraryRoot = this.settings.ensureLibraryPath();
     const existing = this.database.listFiles();
   const existingByPath = new Map(existing.map((file) => [file.absolutePath, file] as const));
@@ -213,6 +235,20 @@ export class LibraryService {
     return this.database.listFiles();
   }
 
+  /**
+   * Attempts to resolve a file summary by id. Returns null when the record no longer exists.
+   */
+  public getFileById(fileId: number): AudioFileSummary | null {
+    try {
+      return this.database.getFileById(fileId);
+    } catch (error) {
+      if (error instanceof Error) {
+        console.warn(`Failed to resolve file by id ${fileId}:`, error.message);
+      }
+      return null;
+    }
+  }
+
   /**
    * Returns groups of files that have identical checksums (potential duplicates).
    */
@@ -267,6 +303,138 @@ export class LibraryService {
     return cleanedCount;
   }
 
+  /**
+   * Imports external WAV files from the provided sources, copying them into the library while
+   * skipping duplicates based on the audio checksum. Imported files land under `_Imports/<date>`.
+   */
+  public async importExternalSources(sourcePaths: string[]): Promise<LibraryImportResult> {
+    // eslint-disable-next-line no-console -- Log import start for debugging.
+    console.log('Starting import from:', sourcePaths);
+    
+    if (!Array.isArray(sourcePaths) || sourcePaths.length === 0) {
+      return { imported: [], skipped: [], failed: [] };
+    }
+
+    const libraryRoot = this.settings.ensureLibraryPath();
+    const normalisedLibraryRoot = this.normalizeAbsolutePath(libraryRoot);
+    const libraryRootWithSlash = normalisedLibraryRoot.endsWith('/')
+      ? normalisedLibraryRoot
+      : `${normalisedLibraryRoot}/`;
+
+    const existingFiles = this.database.listFiles();
+    const knownChecksums = new Set<string>();
+    const knownPaths = new Set<string>();
+    for (const file of existingFiles) {
+      if (typeof file.checksum === 'string' && file.checksum.length > 0) {
+        knownChecksums.add(file.checksum);
+      }
+      knownPaths.add(this.normalizeAbsolutePath(file.absolutePath));
+    }
+
+    const importFolderRelativeBase = path.join('_Imports', new Date().toISOString().slice(0, 10));
+    const importFolderAbsolute = path.join(libraryRoot, importFolderRelativeBase);
+    await fs.mkdir(importFolderAbsolute, { recursive: true });
+
+    const { files: candidateFiles, failures } = await this.collectImportCandidates(sourcePaths);
+    
+    // eslint-disable-next-line no-console -- Log discovered files for debugging.
+    console.log(`Found ${candidateFiles.length} candidate files, ${failures.length} collection failures`);
+    if (failures.length > 0) {
+      // eslint-disable-next-line no-console -- Log collection failures for debugging.
+      console.log('Collection failures:', failures);
+    }
+
+    const imported: AudioFileSummary[] = [];
+    const skipped: ImportSkipEntry[] = [];
+    const failed: ImportFailureEntry[] = [...failures];
+    const usedNames = new Set<string>();
+    const allowedExtensions = new Set(['.wav', '.wave']);
+
+    const folderRelativeNormalised = this.normalizeRelativePath(
+      path.relative(libraryRoot, importFolderAbsolute)
+    );
+    const folderForJoin =
+      folderRelativeNormalised === '.' || folderRelativeNormalised.length === 0
+        ? ''
+        : folderRelativeNormalised;
+
+    for (const candidate of candidateFiles) {
+      const extension = path.extname(candidate).toLowerCase();
+      if (!allowedExtensions.has(extension)) {
+        // eslint-disable-next-line no-console -- Log skip reason for debugging.
+        console.log(`Skipping ${candidate}: unsupported extension ${extension}`);
+        skipped.push({ path: candidate, reason: 'unsupported' });
+        continue;
+      }
+
+      const normalisedCandidate = this.normalizeAbsolutePath(candidate);
+      if (
+        normalisedCandidate === normalisedLibraryRoot ||
+        normalisedCandidate.startsWith(libraryRootWithSlash)
+      ) {
+        // eslint-disable-next-line no-console -- Log skip reason for debugging.
+        console.log(`Skipping ${candidate}: already inside library`);
+        skipped.push({ path: candidate, reason: 'inside-library' });
+        continue;
+      }
+
+      if (knownPaths.has(normalisedCandidate)) {
+        // eslint-disable-next-line no-console -- Log skip reason for debugging.
+        console.log(`Skipping ${candidate}: duplicate path`);
+        skipped.push({ path: candidate, reason: 'duplicate' });
+        continue;
+      }
+
+      // eslint-disable-next-line no-console -- Log checksum computation for debugging.
+      console.log(`Computing checksum for ${candidate}...`);
+      const checksum = await this.computeFileChecksum(candidate);
+      if (!checksum) {
+        // eslint-disable-next-line no-console -- Log skip reason for debugging.
+        console.log(`Skipping ${candidate}: checksum computation failed`);
+        skipped.push({ path: candidate, reason: 'checksum' });
+        continue;
+      }
+
+      if (knownChecksums.has(checksum)) {
+        // eslint-disable-next-line no-console -- Log skip reason for debugging.
+        console.log(`Skipping ${candidate}: duplicate checksum ${checksum}`);
+        skipped.push({ path: candidate, reason: 'duplicate' });
+        continue;
+      }
+
+      // eslint-disable-next-line no-console -- Log import attempt for debugging.
+      console.log(`Attempting to import ${candidate} with checksum ${checksum}...`);
+      try {
+        const record = await this.copyAndRegisterImportedFile({
+          sourcePath: candidate,
+          checksum,
+          importFolderAbsolute,
+          folderForJoin,
+          libraryRoot,
+          usedNames
+        });
+        imported.push(record);
+        knownChecksums.add(checksum);
+        knownPaths.add(this.normalizeAbsolutePath(record.absolutePath));
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // eslint-disable-next-line no-console -- Log import failures for debugging.
+        console.error(`Failed to import ${candidate}:`, errorMessage);
+        failed.push({
+          path: candidate,
+          message: errorMessage
+        });
+      }
+    }
+
+    if (imported.length > 0) {
+      this.resetMetadataSuggestionsCache();
+      this.search.rebuildIndex();
+    }
+
+    return { imported, skipped, failed };
+  }
+
   /**
    * Renames a file while keeping it in the current directory.
    */
@@ -344,7 +512,7 @@ export class LibraryService {
   const buffer = await fs.readFile(record.absolutePath);
   const wave = new WaveFile(buffer);
   const sampleBlock = wave.getSamples(false, Float64Array) as Float64Array | Float64Array[];
-  const channels = Array.isArray(sampleBlock) ? sampleBlock : [sampleBlock];
+  const channels = (Array.isArray(sampleBlock) ? sampleBlock : [sampleBlock]) as Float64Array[];
       const firstChannel = channels[0];
 
       if (!firstChannel || firstChannel.length === 0) {
@@ -751,7 +919,9 @@ export class LibraryService {
           startMs,
           endMs: safeEnd,
           label: segment.label?.trim() ?? undefined,
-          metadata: segment.metadata
+          metadata: segment.metadata,
+          fadeInMs: Number.isFinite(segment.fadeInMs) ? Math.max(0, Math.floor(segment.fadeInMs!)) : 0,
+          fadeOutMs: Number.isFinite(segment.fadeOutMs) ? Math.max(0, Math.floor(segment.fadeOutMs!)) : 0
         };
       })
       .filter((segment) => segment.endMs - segment.startMs >= 5)
@@ -780,7 +950,14 @@ export class LibraryService {
         continue;
       }
 
-      const segmentChannels = channels.map((channel) => channel.slice(startSample, endSample));
+  let segmentChannels: Float64Array[] = channels.map((channel) => channel.slice(startSample, endSample));
+
+      const fadeInMs = segment.fadeInMs ?? 0;
+      const fadeOutMs = segment.fadeOutMs ?? 0;
+      if (fadeInMs > 0 || fadeOutMs > 0) {
+        segmentChannels = (await this.applyFadeEnvelopeToSegment(segmentChannels, sampleRate, fadeInMs, fadeOutMs)) as Float64Array[];
+      }
+
       const nextWave = new WaveFile();
       nextWave.fromScratch(channels.length, sampleRate, bitDepthText, segmentChannels.length === 1 ? segmentChannels[0] : segmentChannels);
       (nextWave as WaveFile & { container?: string }).container = container;
@@ -902,6 +1079,152 @@ export class LibraryService {
     return created;
   }
 
+  /**
+   * Applies the configured fade envelope to the provided channel data. Tries to render using
+   * `standardized-audio-context` for consistency with the editor preview and falls back to
+   * a manual smooth-step implementation if the dependency is unavailable at runtime.
+   */
+  private async applyFadeEnvelopeToSegment(
+    source: Float64Array[],
+    sampleRate: number,
+    fadeInMs: number,
+    fadeOutMs: number
+  ): Promise<Float64Array[]> {
+    if (source.length === 0 || source[0]?.length === 0) {
+      return source.map((channel) => channel.slice());
+    }
+
+    const totalSamples = source[0].length;
+    const fadeInSamples = Math.min(totalSamples, Math.max(0, Math.floor((fadeInMs / 1000) * sampleRate)));
+    const fadeOutSamples = Math.min(totalSamples, Math.max(0, Math.floor((fadeOutMs / 1000) * sampleRate)));
+
+    if (fadeInSamples === 0 && fadeOutSamples === 0) {
+      return source.map((channel) => channel.slice());
+    }
+
+    const applyManual = (): Float64Array[] => {
+      return source.map((channel) => {
+        const copy = channel.slice();
+        const sampleCount = copy.length;
+        const fadeInDenominator = Math.max(1, fadeInSamples - 1);
+        const fadeOutDenominator = Math.max(1, fadeOutSamples - 1);
+        for (let index = 0; index < sampleCount; index += 1) {
+          let gain = 1;
+          if (fadeInSamples > 0 && index < fadeInSamples) {
+            const t = fadeInDenominator > 0 ? index / fadeInDenominator : 0;
+            const eased = this.smoothStep(t);
+            gain = Math.min(gain, eased);
+          }
+          if (fadeOutSamples > 0) {
+            const fromEnd = sampleCount - 1 - index;
+            if (fromEnd < fadeOutSamples) {
+              const t = fadeOutDenominator > 0 ? fromEnd / fadeOutDenominator : 0;
+              const eased = this.smoothStep(t);
+              gain = Math.min(gain, eased);
+            }
+          }
+          copy[index] = copy[index] * gain;
+        }
+        return copy;
+      });
+    };
+
+    try {
+      let OfflineContextCtor = this.offlineAudioContextCtor;
+      if (!OfflineContextCtor) {
+        const audioModule = (await import('standardized-audio-context')) as {
+          OfflineAudioContext?: new (channelCount: number, length: number, sampleRate: number) => any;
+          default?: { OfflineAudioContext?: new (channelCount: number, length: number, sampleRate: number) => any };
+        };
+        const resolvedCtor = audioModule.OfflineAudioContext ?? audioModule.default?.OfflineAudioContext ?? null;
+        if (typeof resolvedCtor !== 'function') {
+          return applyManual();
+        }
+        this.offlineAudioContextCtor = resolvedCtor;
+        OfflineContextCtor = resolvedCtor;
+      }
+
+      const channelCount = source.length;
+      const offlineContext = new OfflineContextCtor(channelCount, totalSamples, sampleRate);
+      const buffer = offlineContext.createBuffer(channelCount, totalSamples, sampleRate);
+      for (let channelIndex = 0; channelIndex < channelCount; channelIndex += 1) {
+        const channelData = buffer.getChannelData(channelIndex);
+        const sourceChannel = source[channelIndex];
+        for (let sampleIndex = 0; sampleIndex < totalSamples; sampleIndex += 1) {
+          channelData[sampleIndex] = sourceChannel?.[sampleIndex] ?? 0;
+        }
+      }
+
+      const bufferSource = offlineContext.createBufferSource();
+      bufferSource.buffer = buffer;
+      const gainNode = offlineContext.createGain();
+      bufferSource.connect(gainNode);
+      gainNode.connect(offlineContext.destination);
+
+      const totalDurationSeconds = totalSamples / sampleRate;
+      gainNode.gain.setValueAtTime(1, 0);
+
+      if (fadeInSamples > 0) {
+        const fadeInCurve = this.generateFadeCurve(Math.max(fadeInSamples, 2), 'in');
+        gainNode.gain.setValueAtTime(fadeInCurve[0], 0);
+        gainNode.gain.setValueCurveAtTime(fadeInCurve, 0, fadeInSamples / sampleRate);
+        gainNode.gain.setValueAtTime(1, fadeInSamples / sampleRate);
+      }
+
+      if (fadeOutSamples > 0) {
+        const fadeOutCurve = this.generateFadeCurve(Math.max(fadeOutSamples, 2), 'out');
+        const fadeOutStart = Math.max(0, totalDurationSeconds - fadeOutSamples / sampleRate);
+        gainNode.gain.setValueAtTime(1, fadeOutStart);
+        gainNode.gain.setValueCurveAtTime(fadeOutCurve, fadeOutStart, fadeOutSamples / sampleRate);
+        gainNode.gain.setValueAtTime(fadeOutCurve[fadeOutCurve.length - 1], totalDurationSeconds);
+      }
+
+      bufferSource.start(0);
+      const renderedBuffer = await offlineContext.startRendering();
+      const processed: Float64Array[] = [];
+      for (let channelIndex = 0; channelIndex < channelCount; channelIndex += 1) {
+        const renderedChannel = renderedBuffer.getChannelData(channelIndex);
+        const clone = new Float64Array(renderedChannel.length);
+        clone.set(renderedChannel);
+        processed.push(clone);
+      }
+      return processed;
+    } catch (error) {
+      console.warn('Falling back to manual fade processing', error);
+      return applyManual();
+    }
+  }
+
+  /**
+   * Generates a smooth fade curve using a cubic smooth-step easing function.
+   */
+  private generateFadeCurve(sampleCount: number, direction: 'in' | 'out'): Float32Array {
+    const totalSamples = Math.max(sampleCount, 2);
+    const curve = new Float32Array(totalSamples);
+    const lastIndex = totalSamples - 1;
+    for (let index = 0; index < totalSamples; index += 1) {
+      const t = lastIndex === 0 ? 1 : index / lastIndex;
+      const eased = this.smoothStep(Math.min(Math.max(t, 0), 1));
+      curve[index] = direction === 'in' ? eased : 1 - eased;
+    }
+    if (direction === 'in') {
+      curve[0] = 0;
+      curve[lastIndex] = 1;
+    } else {
+      curve[0] = 1;
+      curve[lastIndex] = 0;
+    }
+    return curve;
+  }
+
+  /**
+   * Computes the cubic smooth-step easing value for the provided normalised progress.
+   */
+  private smoothStep(t: number): number {
+    const clamped = Math.min(Math.max(t, 0), 1);
+    return clamped * clamped * (3 - 2 * clamped);
+  }
+
   /**
    * Returns the previously parsed UCS category catalog.
    */
@@ -1172,6 +1495,165 @@ export class LibraryService {
     return value.replace(/\\/g, '/');
   }
 
+  /**
+   * Gathers candidate audio files from the provided sources, handling both folders and individual files.
+   */
+  private async collectImportCandidates(sourcePaths: string[]): Promise<{
+    files: string[];
+    failures: ImportFailureEntry[];
+  }> {
+    const discovered = new Set<string>();
+    const failures: ImportFailureEntry[] = [];
+    const uniqueSources = Array.from(
+      new Set((sourcePaths ?? []).map((entry) => entry?.trim()).filter((entry): entry is string => Boolean(entry)))
+    );
+
+    for (const rawSource of uniqueSources) {
+      const absoluteSource = path.resolve(rawSource);
+      try {
+        const stats = await fs.stat(absoluteSource);
+        if (stats.isDirectory()) {
+          try {
+            const matches = await fg(['**/*.wav', '**/*.wave'], {
+              cwd: absoluteSource,
+              absolute: true,
+              onlyFiles: true,
+              suppressErrors: true,
+              caseSensitiveMatch: false
+            });
+            for (const match of matches) {
+              discovered.add(path.resolve(match));
+            }
+          } catch (error) {
+            failures.push({
+              path: absoluteSource,
+              message: error instanceof Error ? error.message : String(error)
+            });
+          }
+        } else if (stats.isFile()) {
+          discovered.add(absoluteSource);
+        } else {
+          failures.push({ path: absoluteSource, message: 'Unsupported file system entry.' });
+        }
+      } catch (error) {
+        failures.push({
+          path: absoluteSource,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+
+    const files = Array.from(discovered).sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+    return { files, failures };
+  }
+
+  /**
+   * Copies a single source file into the library and registers it in the database, returning the stored record.
+   */
+  private async copyAndRegisterImportedFile(options: {
+    sourcePath: string;
+    checksum: string;
+    importFolderAbsolute: string;
+    folderForJoin: string;
+    libraryRoot: string;
+    usedNames: Set<string>;
+  }): Promise<AudioFileSummary> {
+    const { sourcePath, checksum, importFolderAbsolute, folderForJoin, libraryRoot, usedNames } = options;
+    const extension = path.extname(sourcePath);
+    const baseName = path.basename(sourcePath, extension);
+    let sanitizedBase = this.organization.sanitizeCustomName(baseName);
+    if (!sanitizedBase) {
+      sanitizedBase = 'Imported';
+    }
+
+    let attempt = 0;
+    let candidateName: string = '';
+    let candidateAbsolutePath: string = '';
+    while (true) {
+      if (attempt === 0) {
+        candidateName = this.normaliseFileName(`${sanitizedBase}.wav`);
+      } else {
+        const suffix = this.organization.formatSequenceNumber(attempt);
+        candidateName = this.normaliseFileName(`${sanitizedBase}_${suffix}.wav`);
+      }
+
+      if (!usedNames.has(candidateName)) {
+        candidateAbsolutePath = path.join(importFolderAbsolute, candidateName);
+        const exists = await this.pathExists(candidateAbsolutePath);
+        if (!exists) {
+          break;
+        }
+      }
+
+      attempt += 1;
+      if (attempt > 9999) {
+        throw new Error('Unable to allocate a unique filename for the imported file.');
+      }
+    }
+
+    usedNames.add(candidateName);
+    this.assertWithinLibrary(libraryRoot, candidateAbsolutePath);
+
+    await fs.copyFile(sourcePath, candidateAbsolutePath);
+
+    try {
+      const stats = await fs.stat(candidateAbsolutePath);
+      const metadata = await this.extractAudioMetadata(candidateAbsolutePath);
+      const relativePath = this.toLibraryRelativePath(folderForJoin, candidateName);
+      const record = this.database.upsertFile({
+        absolutePath: candidateAbsolutePath,
+        relativePath,
+        fileName: candidateName,
+        displayName: path.basename(candidateName, path.extname(candidateName)),
+        modifiedAt: stats.mtimeMs,
+        createdAt: Number.isNaN(stats.birthtimeMs) ? null : stats.birthtimeMs,
+        size: stats.size,
+        durationMs: metadata.durationMs,
+        sampleRate: metadata.sampleRate,
+        bitDepth: metadata.bitDepth,
+        checksum,
+        tags: metadata.tags,
+        categories: metadata.categories
+      });
+
+      try {
+        const embedded = this.tagService.readMetadata(candidateAbsolutePath);
+        this.updateMetadataSuggestionsCache(embedded.author ?? null);
+      } catch (metadataError) {
+        // eslint-disable-next-line no-console -- Import should continue even if metadata read fails.
+        console.warn('Failed to read metadata from imported file', metadataError);
+      }
+
+      return record;
+    } catch (error) {
+      await fs.rm(candidateAbsolutePath, { force: true }).catch(() => undefined);
+      throw error;
+    }
+  }
+
+  /**
+   * Resolves and caches the music-metadata parseFile implementation.
+   */
+  private async resolveMusicMetadataParser(): Promise<MusicMetadataParser> {
+    if (this.musicMetadataParseFile) {
+      return this.musicMetadataParseFile;
+    }
+
+    const namespace = (await import('music-metadata')) as MusicMetadataNamespace;
+    const candidate = typeof namespace.parseFile === 'function'
+      ? namespace.parseFile
+      : namespace.default && typeof namespace.default.parseFile === 'function'
+        ? namespace.default.parseFile
+        : null;
+
+    if (!candidate) {
+      throw new Error('music-metadata parseFile not found');
+    }
+
+    this.musicMetadataParseFile = candidate;
+    return candidate;
+  }
+
   /**
    * Extracts metadata from the WAV container, falling back to defaults when parsing fails.
    */
@@ -1183,22 +1665,8 @@ export class LibraryService {
     categories: string[];
   }> {
     try {
-      const mmImport = await import('music-metadata');
-      const mm = (mmImport as { default?: unknown }).default ?? mmImport;
-      
-      const loadMusicMetadata = typeof mm === 'object' && mm !== null && 'loadMusicMetadata' in mm
-        ? (mm as { loadMusicMetadata: () => Promise<{ parseFile: (path: string, opts?: { duration?: boolean }) => Promise<{
-            format: { duration?: number | null; sampleRate?: number | null; bitsPerSample?: number | null };
-            common: { comment?: unknown[]; genre?: unknown[]; subtitle?: unknown };
-          }> }> }).loadMusicMetadata
-        : null;
-      
-      if (!loadMusicMetadata) {
-        throw new Error('music-metadata loadMusicMetadata not found');
-      }
-      
-      const musicMetadata = await loadMusicMetadata();
-      const metadata = await musicMetadata.parseFile(filePath, { duration: true });
+      const parseFile = await this.resolveMusicMetadataParser();
+      const metadata = await parseFile(filePath, { duration: true });
       const infoTags = this.tagService.readInfoTags(filePath);
       const splitInfoValues = (input: string | undefined): string[] =>
         input

src/main/services/SearchService.ts

@@ -1,4 +1,4 @@
-import Fuse from 'fuse.js';
+import Fuse, { type FuseResult, type IFuseOptions } from 'fuse.js';
 import { AudioFileSummary } from '../../shared/models';
 import { DatabaseService } from './DatabaseService';
 import { TagService } from './TagService';
@@ -76,7 +76,7 @@ export class SearchService {
 
     return fuseInstance
       .search(remainingQuery)
-      .map((result: Fuse.FuseResult<AudioFileSummary>) => result.item)
+      .map((result: FuseResult<AudioFileSummary>) => result.item)
       .filter((file) => (filters.length === 0 ? true : this.matchesAdvancedFilters(file, filters)));
   }
 
@@ -103,7 +103,7 @@ export class SearchService {
   /**
    * Provides the standard Fuse configuration used by the service.
    */
-  private createFuseOptions(): Fuse.IFuseOptions<AudioFileSummary> {
+  private createFuseOptions(): IFuseOptions<AudioFileSummary> {
     return {
       includeScore: true,
       threshold: 0.35,
@@ -114,7 +114,7 @@ export class SearchService {
         { name: 'tags', weight: 0.2 },
         { name: 'categories', weight: 0.1 }
       ]
-    } satisfies Fuse.IFuseOptions<AudioFileSummary>;
+    } satisfies IFuseOptions<AudioFileSummary>;
   }
 
   /**

src/main/services/TagService.ts

@@ -163,8 +163,8 @@ export class TagService {
         .filter((entry) => entry.length > 0);
 
       const tagText = tagValuesList.length > 0 ? tagValuesList.join('; ') : null;
-      const categoryText = categoryValuesList.length > 0 ? categoryValuesList.join('; ') : null;
-      const primaryCategory = categoryValuesList.at(0) ?? null;
+  const categoryText = categoryValuesList.length > 0 ? categoryValuesList.join('; ') : null;
+  const primaryCategory = categoryValuesList.length > 0 ? categoryValuesList[0] : null;
       const trimmedTitle = metadata.title?.toString().trim();
       const effectiveTitle = trimmedTitle && trimmedTitle.length > 0 ? trimmedTitle : null;
       const trimmedAuthor = metadata.author?.toString().trim();

src/main/types/standardized-audio-context.d.ts

@@ -0,0 +1,10 @@
+declare module 'standardized-audio-context' {
+  export class OfflineAudioContext {
+    constructor(channelCount: number, length: number, sampleRate: number);
+    createBuffer(channelCount: number, length: number, sampleRate: number): any;
+    createBufferSource(): any;
+    createGain(): any;
+    startRendering(): Promise<any>;
+    readonly destination: any;
+  }
+}

src/preload/index.ts

@@ -5,6 +5,7 @@ import type {
   AudioBufferPayload,
   AudioFileSummary,
   CategoryRecord,
+  LibraryImportResult,
   LibraryScanSummary,
   SplitSegmentRequest,
   TagUpdatePayload
@@ -26,9 +27,22 @@ const api: RendererApi = {
   async rescanLibrary(): Promise<LibraryScanSummary> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryScan);
   },
+  async selectImportFolder(): Promise<string | null> {
+    return ipcRenderer.invoke(IPC_CHANNELS.dialogSelectImportFolder);
+  },
+  async listSystemDrives(): Promise<string[]> {
+    return ipcRenderer.invoke(IPC_CHANNELS.systemListDrives);
+  },
   async listAudioFiles(): Promise<AudioFileSummary[]> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryList);
   },
+  async importExternalSources(paths: string[]): Promise<LibraryImportResult> {
+    return ipcRenderer.invoke(IPC_CHANNELS.libraryImport, paths);
+  },
+  /** Retrieves a single audio file summary by id, returning null when the record no longer exists. */
+  async getAudioFileById(fileId: number): Promise<AudioFileSummary | null> {
+    return ipcRenderer.invoke(IPC_CHANNELS.libraryGetById, fileId);
+  },
   async listDuplicates(): Promise<{ checksum: string; files: AudioFileSummary[] }[]> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryDuplicates);
   },
@@ -83,8 +97,8 @@ const api: RendererApi = {
   ): Promise<void> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryUpdateMetadata, fileId, metadata);
   },
-  onMenuAction(channel: string, callback: () => void): () => void {
-    const listener = () => callback();
+  onMenuAction(channel: string, callback: (payload?: unknown) => void): () => void {
+    const listener = (_event: Electron.IpcRendererEvent, payload?: unknown) => callback(payload);
     ipcRenderer.on(channel, listener);
     return () => ipcRenderer.removeListener(channel, listener);
   }

src/renderer/src/App.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState, type JSX } from 'react';
 import FileList from './components/FileList';
 import FileDetailPanel from './components/FileDetailPanel';
 import MultiFileEditor from './components/MultiFileEditor';
@@ -10,7 +10,7 @@ import EditModePanel from './components/edit/EditModePanel';
 import { useLibrarySnapshot } from './hooks/useLibrarySnapshot';
 import { loadPlayerFile, usePlayerSnapshot } from './hooks/usePlayerSnapshot';
 import { libraryStore, type CategoryFilterValue } from './stores/LibraryStore';
-import type { AudioFileSummary } from '../../shared/models';
+import type { AudioFileSummary, LibraryImportResult } from '../../shared/models';
 
 type RightPanelTab = 'listen' | 'edit';
 
@@ -25,14 +25,18 @@ function App(): JSX.Element {
   const [showStatusMessage, setShowStatusMessage] = useState(false);
   const [statusFadingOut, setStatusFadingOut] = useState(false);
   const [activeTab, setActiveTab] = useState<RightPanelTab>('listen');
+  const [importMessage, setImportMessage] = useState<string | null>(null);
   
   const statusMessage = useMemo(() => {
+    if (importMessage) {
+      return importMessage;
+    }
     if (!library.lastScan) {
       return null;
     }
     const { added, updated, removed } = library.lastScan;
     return `Scan complete: +${added} updated ${updated} removed ${removed}`;
-  }, [library.lastScan]);
+  }, [importMessage, library.lastScan]);
 
   useEffect(() => {
     if (statusMessage) {
@@ -44,6 +48,7 @@ function App(): JSX.Element {
       const hideTimer = setTimeout(() => {
         setShowStatusMessage(false);
         setStatusFadingOut(false);
+        setImportMessage((current) => (current === statusMessage ? null : current));
       }, 5000);
       return () => {
         clearTimeout(fadeTimer);
@@ -52,24 +57,12 @@ function App(): JSX.Element {
     }
   }, [statusMessage]);
 
-  useEffect(() => {
-    const cleanup1 = window.api.onMenuAction('open-settings', () => setSettingsOpen(true));
-    const cleanup2 = window.api.onMenuAction('rescan-library', handleRescan);
-    const cleanup3 = window.api.onMenuAction('find-duplicates', handleFindDuplicates);
-
-    return () => {
-      cleanup1();
-      cleanup2();
-      cleanup3();
-    };
-  }, []);
-
   const selectedFile = useMemo(
     () => library.files.find((file) => file.id === library.selectedFileId) ?? null,
     [library.files, library.selectedFileId]
   );
 
-  const parentFile = useMemo(() => {
+  const parentFileFromStore = useMemo(() => {
     const parentId = selectedFile?.parentFileId ?? null;
     if (parentId === null) {
       return null;
@@ -77,6 +70,39 @@ function App(): JSX.Element {
     return library.files.find((file) => file.id === parentId) ?? null;
   }, [library.files, selectedFile?.parentFileId]);
 
+  const [resolvedParentFile, setResolvedParentFile] = useState<AudioFileSummary | null>(parentFileFromStore);
+
+  useEffect(() => {
+    const parentId = selectedFile?.parentFileId ?? null;
+    if (parentId === null) {
+      setResolvedParentFile(null);
+      return;
+    }
+    if (parentFileFromStore) {
+      setResolvedParentFile(parentFileFromStore);
+      return;
+    }
+
+    let cancelled = false;
+    (async () => {
+      try {
+        const fetched = await window.api.getAudioFileById(parentId);
+        if (!cancelled) {
+          setResolvedParentFile(fetched ?? null);
+        }
+      } catch (error) {
+        console.warn('Unable to resolve parent file details', { parentId, error });
+        if (!cancelled) {
+          setResolvedParentFile(null);
+        }
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [parentFileFromStore, selectedFile?.parentFileId]);
+
   const selectedFiles = useMemo(
     () => library.files.filter((file) => library.selectedFileIds.has(file.id)),
     [library.files, library.selectedFileIds]
@@ -122,14 +148,82 @@ function App(): JSX.Element {
     void libraryStore.search(value);
   };
 
-  const handleRescan = async () => {
+  const handleRescan = useCallback(async () => {
     await libraryStore.rescan();
-  };
+  }, []);
 
-  const handleFindDuplicates = async () => {
+  const handleFindDuplicates = useCallback(async () => {
     const duplicates = await window.api.listDuplicates();
     setDuplicateGroups(duplicates);
-  };
+  }, []);
+
+  const summariseImportResult = useCallback((result: LibraryImportResult): string => {
+    const parts: string[] = [`${result.imported.length} added`];
+    if (result.skipped.length > 0) {
+      parts.push(`${result.skipped.length} skipped`);
+    }
+    if (result.failed.length > 0) {
+      parts.push(`${result.failed.length} failed`);
+    }
+    return `Import complete: ${parts.join(', ')}`;
+  }, []);
+
+  const notifyImportSuccess = useCallback((result: LibraryImportResult) => {
+    setImportMessage(summariseImportResult(result));
+  }, [summariseImportResult]);
+
+  const notifyImportFailure = useCallback(() => {
+    setImportMessage('Import failed. Check logs for details.');
+  }, []);
+
+  const handleImportFromFolder = useCallback(async () => {
+    try {
+      const result = await libraryStore.importFromFolder();
+      if (!result) {
+        return;
+      }
+      notifyImportSuccess(result);
+    } catch (error) {
+      console.error('Import failed', error);
+      notifyImportFailure();
+    }
+  }, [notifyImportFailure, notifyImportSuccess]);
+
+  const handleImportFromDrive = useCallback(async (drive: string) => {
+    try {
+      const result = await libraryStore.importFromDrive(drive);
+      notifyImportSuccess(result);
+    } catch (error) {
+      console.error('Import failed', error);
+      notifyImportFailure();
+    }
+  }, [notifyImportFailure, notifyImportSuccess]);
+
+  useEffect(() => {
+    const cleanup1 = window.api.onMenuAction('open-settings', () => setSettingsOpen(true));
+    const cleanup2 = window.api.onMenuAction('rescan-library', () => {
+      void handleRescan();
+    });
+    const cleanup3 = window.api.onMenuAction('find-duplicates', () => {
+      void handleFindDuplicates();
+    });
+    const cleanup4 = window.api.onMenuAction('import-from-folder', () => {
+      void handleImportFromFolder();
+    });
+    const cleanup5 = window.api.onMenuAction('import-from-drive', (drive) => {
+      if (typeof drive === 'string') {
+        void handleImportFromDrive(drive);
+      }
+    });
+
+    return () => {
+      cleanup1();
+      cleanup2();
+      cleanup3();
+      cleanup4();
+      cleanup5();
+    };
+  }, [handleFindDuplicates, handleImportFromFolder, handleImportFromDrive, handleRescan]);
 
   const handleKeepDuplicate = async (fileIdToKeep: number, fileIdsToDelete: number[]) => {
     await window.api.deleteFiles(fileIdsToDelete);
@@ -178,7 +272,7 @@ function App(): JSX.Element {
       if (element) {
         element.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
       }
-    }, 100);
+    }, 5000);
   };
 
   const handleUpdateCustomName = async (customName: string | null) => {
@@ -241,8 +335,7 @@ function App(): JSX.Element {
     setActiveTab('listen');
   };
 
-  const handleEditModeSplitComplete = async (created: AudioFileSummary[]) => {
-    await libraryStore.rescan();
+  const handleEditModeSplitComplete = (created: AudioFileSummary[]) => {
     setActiveTab('listen');
     if (created.length > 0) {
       libraryStore.selectFile(created[0].id);
@@ -261,6 +354,7 @@ function App(): JSX.Element {
           categories={library.categories}
           files={library.files}
           activeFilter={library.categoryFilter}
+          justSplitIds={library.justSplitFileIds}
           onSelect={handleCategorySelect}
           onDropFiles={handleDropFilesToCategory}
         />
@@ -307,7 +401,7 @@ function App(): JSX.Element {
                 <>
                   <FileDetailPanel
                     file={selectedFile}
-                    parentFile={parentFile}
+                    parentFile={resolvedParentFile}
                     categories={library.categories}
                     onRename={handleRename}
                     onMove={handleMove}

src/renderer/src/components/CategorySidebar.tsx

@@ -1,6 +1,6 @@
 import { useMemo } from 'react';
 import type { AudioFileSummary, CategoryRecord } from '../../../shared/models';
-import { CATEGORY_FILTER_UNTAGGED, type CategoryFilterValue } from '../stores/LibraryStore';
+import { CATEGORY_FILTER_JUST_SPLIT, CATEGORY_FILTER_UNTAGGED, type CategoryFilterValue } from '../stores/LibraryStore';
 import {
   buildCategorySwatch,
   createCategoryStyleVars,
@@ -11,6 +11,8 @@ export interface CategorySidebarProps {
   categories: CategoryRecord[];
   files: AudioFileSummary[];
   activeFilter: CategoryFilterValue;
+  /** Identifiers of files created during the most recent split action. */
+  justSplitIds: number[];
   onSelect(filter: CategoryFilterValue): void;
   onDropFiles?(fileIds: number[], categoryId: string): void;
 }
@@ -37,7 +39,7 @@ function deriveCounts(files: AudioFileSummary[]): {
   };
 }
 
-export function CategorySidebar({ categories, files, activeFilter, onSelect, onDropFiles }: CategorySidebarProps): JSX.Element {
+export function CategorySidebar({ categories, files, activeFilter, justSplitIds, onSelect, onDropFiles }: CategorySidebarProps): JSX.Element {
   const { total, untagged, categoryCounts } = deriveCounts(files);
   const swatchMap = useMemo(() => {
     const map = new Map<string, ReturnType<typeof buildCategorySwatch>>();
@@ -103,6 +105,17 @@ export function CategorySidebar({ categories, files, activeFilter, onSelect, onD
           <span className="category-sidebar__label">TO TAG</span>
           <span className="category-sidebar__count">{untagged}</span>
         </button>
+        {justSplitIds.length > 0 ? (
+          <button
+            type="button"
+            className="category-sidebar__item"
+            data-active={activeFilter === CATEGORY_FILTER_JUST_SPLIT}
+            onClick={() => handleSelect(CATEGORY_FILTER_JUST_SPLIT)}
+          >
+            <span className="category-sidebar__label">JUST SPLIT</span>
+            <span className="category-sidebar__count">{justSplitIds.length}</span>
+          </button>
+        ) : null}
       </div>
       {sortedGroups.map(([groupName, records]) => {
         const sortedRecords = records

src/renderer/src/components/DrivePickerDialog.tsx

@@ -0,0 +1,78 @@
+import type { JSX } from 'react';
+
+export interface DrivePickerDialogProps {
+  drives: string[];
+  loading: boolean;
+  importing: boolean;
+  error: string | null;
+  onRefresh(): void;
+  onSelect(drivePath: string): void;
+  onClose(): void;
+}
+
+/**
+ * Modal dialog that lists available system drives for import selection.
+ */
+export function DrivePickerDialog({
+  drives,
+  loading,
+  importing,
+  error,
+  onRefresh,
+  onSelect,
+  onClose
+}: DrivePickerDialogProps): JSX.Element {
+  const handleBackdropClick = () => {
+    if (!importing && !loading) {
+      onClose();
+    }
+  };
+
+  return (
+    <div className="modal-overlay" onClick={handleBackdropClick}>
+      <div className="modal-content drive-picker" onClick={(event) => event.stopPropagation()}>
+        <header className="drive-picker__header">
+          <h2>Import From Drive</h2>
+          <p>Select a drive to copy new WAV files into your library.</p>
+        </header>
+
+        {error ? <div className="drive-picker__error">{error}</div> : null}
+
+        <div className="drive-picker__body">
+          {loading ? (
+            <p className="drive-picker__status">Loading available drives…</p>
+          ) : drives.length === 0 ? (
+            <p className="drive-picker__status">No drives were detected.</p>
+          ) : (
+            <ul className="drive-picker__list">
+              {drives.map((drive) => (
+                <li key={drive}>
+                  <button
+                    type="button"
+                    className="drive-picker__drive"
+                    onClick={() => onSelect(drive)}
+                    disabled={importing}
+                  >
+                    <span className="drive-picker__drive-label">{drive}</span>
+                    <span className="drive-picker__drive-hint">Press Enter to import from this drive</span>
+                  </button>
+                </li>
+              ))}
+            </ul>
+          )}
+        </div>
+
+        <footer className="drive-picker__footer">
+          <button type="button" className="ghost-button" onClick={onRefresh} disabled={loading || importing}>
+            Refresh Drives
+          </button>
+          <button type="button" className="ghost-button" onClick={onClose} disabled={importing}>
+            Close
+          </button>
+        </footer>
+      </div>
+    </div>
+  );
+}
+
+export default DrivePickerDialog;

src/renderer/src/components/FileDetailPanel.tsx

@@ -369,7 +369,7 @@ export function FileDetailPanel({ file, parentFile, categories, onRename, onMove
               onClick={handleOpenParent}
               title={parentFile ? `Open source file ${parentFile.displayName}` : 'Open source file'}
             >
-              🔗 {parentFile ? parentFile.customName || parentFile.displayName : `File #${file.parentFileId}`}
+              🔗 {parentFile ? parentFile.customName || parentFile.displayName : `Source missing (#${file.parentFileId})`}
             </button>
           ) : null}
         </div>

src/renderer/src/components/edit/EditModePanel.tsx

@@ -189,7 +189,39 @@ export function EditModePanel({ file, categories, onClose, onSplitComplete }: Ed
         const playbackLengthMs = absoluteEndMs - playbackStartMs;
         const source = context.createBufferSource();
         source.buffer = buffer;
-        source.connect(context.destination);
+        
+        // Create a gain node for fade control
+        const gainNode = context.createGain();
+        source.connect(gainNode);
+        gainNode.connect(context.destination);
+        
+        // Apply fade in/out if playing a segment
+        if (request.mode === 'segment' && request.segmentId) {
+          const segment = segments.find((s) => s.id === request.segmentId);
+          if (segment) {
+            const fadeInMs = Math.min(segment.fadeInMs, playbackLengthMs / 2);
+            const fadeOutMs = Math.min(segment.fadeOutMs, playbackLengthMs / 2);
+            const currentTime = context.currentTime;
+            
+            // Set initial gain
+            gainNode.gain.setValueAtTime(fadeInMs > 0 ? 0 : 1, currentTime);
+            
+            // Apply fade in
+            if (fadeInMs > 0) {
+              const fadeInEndTime = currentTime + (fadeInMs / 1000);
+              gainNode.gain.linearRampToValueAtTime(1, fadeInEndTime);
+            }
+            
+            // Apply fade out
+            if (fadeOutMs > 0) {
+              const fadeOutStartTime = currentTime + ((playbackLengthMs - fadeOutMs) / 1000);
+              const fadeOutEndTime = currentTime + (playbackLengthMs / 1000);
+              gainNode.gain.setValueAtTime(1, fadeOutStartTime);
+              gainNode.gain.linearRampToValueAtTime(0, fadeOutEndTime);
+            }
+          }
+        }
+        
         source.start(0, playbackStartMs / 1000, playbackLengthMs / 1000);
 
         playbackInfoRef.current = { ...request };
@@ -230,7 +262,7 @@ export function EditModePanel({ file, categories, onClose, onSplitComplete }: Ed
         stopPlaybackCursorTracking();
       }
     },
-    [ensureAudioContext, loadAudioBuffer, stopActiveSource, schedulePlaybackCursorUpdate, stopPlaybackCursorTracking]
+    [ensureAudioContext, loadAudioBuffer, stopActiveSource, schedulePlaybackCursorUpdate, stopPlaybackCursorTracking, segments]
   );
 
   const pausePlayback = useCallback(() => {
@@ -403,7 +435,9 @@ export function EditModePanel({ file, categories, onClose, onSplitComplete }: Ed
       endMs: end,
       label: `Segment ${segments.length + 1}`,
       metadata: buildDefaultMetadata(file, baseMetadata),
-      color: generateSegmentColor(segments.length)
+      color: generateSegmentColor(segments.length),
+      fadeInMs: 0,
+      fadeOutMs: 0
     };
     setSegments((current) => {
       const next = [...current, newSegment].sort((a, b) => a.startMs - b.startMs);
@@ -463,6 +497,16 @@ export function EditModePanel({ file, categories, onClose, onSplitComplete }: Ed
     );
   };
 
+  const handleUpdateFade = useCallback((segmentId: string, fadeInMs: number, fadeOutMs: number) => {
+    setSegments((current) =>
+      current.map((segment) =>
+        segment.id === segmentId
+          ? { ...segment, fadeInMs, fadeOutMs }
+          : segment
+      )
+    );
+  }, []);
+
   const handleRemoveSegment = useCallback((segmentId: string) => {
     setSegments((current) => current.filter((segment) => segment.id !== segmentId));
     setSelectedSegmentId((current) => (current === segmentId ? null : current));
@@ -570,6 +614,7 @@ export function EditModePanel({ file, categories, onClose, onSplitComplete }: Ed
                   onResizeSegment={handleResizeSegment}
                   onPlayFromCursor={playFromCursor}
                   playbackCursorMs={playbackCursorMs}
+                  onUpdateFade={handleUpdateFade}
                 />
               )}
             </div>

src/renderer/src/components/edit/WaveformEditorCanvas.tsx

@@ -21,6 +21,8 @@ export interface WaveformEditorCanvasProps {
   onPlayFromCursor(startMs: number): void;
   /** Location of the active playback cursor relative to the source audio, if playing. */
   playbackCursorMs: number | null;
+  /** Invoked when fade in/out values change. */
+  onUpdateFade(segmentId: string, fadeInMs: number, fadeOutMs: number): void;
 }
 
 interface DraftSelection {
@@ -32,7 +34,8 @@ type DragState =
   | { type: 'none' }
   | { type: 'creating'; anchorMs: number; pointerMs: number }
   | { type: 'resizing'; segmentId: string; handle: 'start' | 'end' }
-  | { type: 'panning'; startViewportMs: number; pointerStartX: number };
+  | { type: 'panning'; startViewportMs: number; pointerStartX: number }
+  | { type: 'fade'; segmentId: string; handle: 'fadeIn' | 'fadeOut'; initialMs: number };
 
 const MIN_SEGMENT_MS = 50;
 const MIN_VIEWPORT_MS = 200;
@@ -53,7 +56,8 @@ export function WaveformEditorCanvas({
   onCreateSegment,
   onResizeSegment,
   onPlayFromCursor,
-  playbackCursorMs
+  playbackCursorMs,
+  onUpdateFade
 }: WaveformEditorCanvasProps): JSX.Element {
   const canvasRef = useRef<HTMLCanvasElement | null>(null);
   const dragStateRef = useRef<DragState>({ type: 'none' });
@@ -179,13 +183,121 @@ export function WaveformEditorCanvas({
       }
       context.fillRect(startX, 0, endX - startX, height);
       
+      // Draw fade curves as bezier splines (volume envelope visualization)
+      const segmentDurationMs = segment.endMs - segment.startMs;
+      const fadeInMs = Math.min(segment.fadeInMs, segmentDurationMs / 2);
+      const fadeOutMs = Math.min(segment.fadeOutMs, segmentDurationMs / 2);
+      
+      const fadeLineColor = isSelected ? '#ffcc00' : (rgbMatch ? `rgb(${parseInt(rgbMatch[1], 16)}, ${parseInt(rgbMatch[2], 16)}, ${parseInt(rgbMatch[3], 16)})` : '#ffffff');
+      
+      // Draw fade in curve (volume ramp from 0 to 1)
+      if (fadeInMs > 0) {
+        const fadeInRatio = fadeInMs / viewportDuration;
+        const fadeInWidth = fadeInRatio * width;
+        const fadeInEndX = startX + fadeInWidth;
+        
+        if (fadeInEndX > startX && fadeInEndX <= endX) {
+          context.strokeStyle = fadeLineColor;
+          context.lineWidth = 2.5;
+          context.beginPath();
+          
+          // Start from bottom (silence) and curve up to full volume
+          context.moveTo(startX, height);
+          
+          // Smooth S-curve using bezier - starts slow, accelerates, then eases in
+          const cp1X = startX + fadeInWidth * 0.3;
+          const cp1Y = height * 0.8;
+          const cp2X = startX + fadeInWidth * 0.7;
+          const cp2Y = height * 0.2;
+          
+          context.bezierCurveTo(
+            cp1X, cp1Y,
+            cp2X, cp2Y,
+            fadeInEndX, 0
+          );
+          context.stroke();
+          
+          // Add a subtle fill under the curve
+          context.globalAlpha = 0.1;
+          context.fillStyle = fadeLineColor;
+          context.lineTo(fadeInEndX, height);
+          context.lineTo(startX, height);
+          context.closePath();
+          context.fill();
+          context.globalAlpha = 1.0;
+        }
+      }
+      
+      // Draw fade out curve (volume ramp from 1 to 0)
+      if (fadeOutMs > 0) {
+        const fadeOutRatio = fadeOutMs / viewportDuration;
+        const fadeOutWidth = fadeOutRatio * width;
+        const fadeOutStartX = endX - fadeOutWidth;
+        
+        if (fadeOutStartX >= startX && fadeOutStartX < endX) {
+          context.strokeStyle = fadeLineColor;
+          context.lineWidth = 2.5;
+          context.beginPath();
+          
+          // Start from top (full volume) and curve down to silence
+          context.moveTo(fadeOutStartX, 0);
+          
+          // Smooth S-curve using bezier
+          const cp1X = fadeOutStartX + fadeOutWidth * 0.3;
+          const cp1Y = height * 0.2;
+          const cp2X = fadeOutStartX + fadeOutWidth * 0.7;
+          const cp2Y = height * 0.8;
+          
+          context.bezierCurveTo(
+            cp1X, cp1Y,
+            cp2X, cp2Y,
+            endX, height
+          );
+          context.stroke();
+          
+          // Add a subtle fill under the curve
+          context.globalAlpha = 0.1;
+          context.fillStyle = fadeLineColor;
+          context.lineTo(endX, height);
+          context.lineTo(fadeOutStartX, height);
+          context.closePath();
+          context.fill();
+          context.globalAlpha = 1.0;
+        }
+      }
+      
       // Use segment color for handles
       context.fillStyle = isSelected ? '#ffcc00' : color;
       context.fillRect(startX - HANDLE_WIDTH_PX / 2, 0, HANDLE_WIDTH_PX, height);
       context.fillRect(endX - HANDLE_WIDTH_PX / 2, 0, HANDLE_WIDTH_PX, height);
+      
+      // Draw corner handles for fade control (DaVinci Resolve style)
+      const dragState = dragStateRef.current;
+      const isFadeDragging = dragState.type === 'fade' && dragState.segmentId === segment.id;
+      const showFadeHandles = isSelected || isFadeDragging;
+      const cornerHandleSize = 12;
+      
+      if (showFadeHandles) {
+        // Top-left corner handle for fade in
+        context.fillStyle = fadeInMs > 0 ? fadeLineColor : 'rgba(255, 255, 255, 0.3)';
+        context.beginPath();
+        context.moveTo(startX, 0);
+        context.lineTo(startX + cornerHandleSize, 0);
+        context.lineTo(startX, cornerHandleSize);
+        context.closePath();
+        context.fill();
+        
+        // Top-right corner handle for fade out
+        context.fillStyle = fadeOutMs > 0 ? fadeLineColor : 'rgba(255, 255, 255, 0.3)';
+        context.beginPath();
+        context.moveTo(endX, 0);
+        context.lineTo(endX - cornerHandleSize, 0);
+        context.lineTo(endX, cornerHandleSize);
+        context.closePath();
+        context.fill();
+      }
 
       // Draw segment labels when being resized or hovered
-      const dragState = dragStateRef.current;
       const shouldShowLabels = (dragState.type === 'resizing' && dragState.segmentId === segment.id) || 
                                (hoveredSegmentId === segment.id && dragState.type === 'none');
       
@@ -449,6 +561,32 @@ export function WaveformEditorCanvas({
 
     const viewport = viewportRef.current;
     const toleranceMs = viewport.durationMs * (HANDLE_WIDTH_PX / Math.max(canvas?.clientWidth ?? 1, 1));
+    
+    // Check for fade handles first (higher priority)
+    const rect = canvas?.getBoundingClientRect();
+    const pointerY = rect ? event.clientY - rect.top : 0;
+    const canvasWidth = canvas?.clientWidth ?? 1;
+    const canvasHeight = canvas?.clientHeight ?? 1;
+    const fadeHit = findFadeHandle(
+      pointerMs, 
+      pointerY, 
+      segments, 
+      viewport.startMs, 
+      viewport.durationMs, 
+      canvasWidth, 
+      canvasHeight
+    );
+    if (fadeHit) {
+      onSelectSegment(fadeHit.segmentId);
+      const segment = segments.find((s) => s.id === fadeHit.segmentId);
+      const initialMs = fadeHit.handle === 'fadeIn' 
+        ? (segment?.fadeInMs ?? 0)
+        : (segment?.fadeOutMs ?? 0);
+      dragStateRef.current = { type: 'fade', segmentId: fadeHit.segmentId, handle: fadeHit.handle, initialMs };
+      clickContextRef.current = null;
+      return;
+    }
+    
     const hit = findSegmentHandle(pointerMs, segments, toleranceMs);
 
     if (hit) {
@@ -591,6 +729,24 @@ export function WaveformEditorCanvas({
         const nextEnd = clamp(pointerMs, Math.max(minEnd, segment.startMs + MIN_SEGMENT_MS), durationMs);
         onResizeSegment(segment.id, segment.startMs, nextEnd);
       }
+      return;
+    }
+    
+    if (state.type === 'fade') {
+      const segment = segments.find((entry) => entry.id === state.segmentId);
+      if (!segment) {
+        return;
+      }
+      const segmentDurationMs = segment.endMs - segment.startMs;
+      const maxFade = segmentDurationMs / 2;
+      
+      if (state.handle === 'fadeIn') {
+        const fadeInMs = clamp(pointerMs - segment.startMs, 0, maxFade);
+        onUpdateFade(segment.id, fadeInMs, segment.fadeOutMs);
+      } else {
+        const fadeOutMs = clamp(segment.endMs - pointerMs, 0, maxFade);
+        onUpdateFade(segment.id, segment.fadeInMs, fadeOutMs);
+      }
     }
   };
 
@@ -854,6 +1010,73 @@ function findSegmentHandle(
   return null;
 }
 
+/**
+ * Detects if the pointer is over a corner fade handle for a segment.
+ * Corner handles are triangular regions at the top-left and top-right of segments.
+ *
+ * @param pointerMs - Absolute timestamp within the audio file to test.
+ * @param pointerY - Y coordinate of the pointer in canvas pixels.
+ * @param segments - Segment collection to evaluate.
+ * @param viewportStartMs - Start of the current viewport.
+ * @param viewportDurationMs - Duration of the current viewport.
+ * @param canvasWidth - Width of the canvas in pixels.
+ * @param canvasHeight - Height of the canvas in pixels.
+ * @returns Fade handle information or null if no corner handle is under the pointer.
+ */
+function findFadeHandle(
+  pointerMs: number,
+  pointerY: number,
+  segments: SegmentDraft[],
+  viewportStartMs: number,
+  viewportDurationMs: number,
+  canvasWidth: number,
+  canvasHeight: number
+): { segmentId: string; handle: 'fadeIn' | 'fadeOut' } | null {
+  const cornerHandleSize = 12;
+  const maxCornerY = 25; // Extended hit area
+  
+  for (const segment of segments) {
+    const startRatio = (segment.startMs - viewportStartMs) / viewportDurationMs;
+    const endRatio = (segment.endMs - viewportStartMs) / viewportDurationMs;
+    const startX = Math.max(0, Math.min(canvasWidth, startRatio * canvasWidth));
+    const endX = Math.max(0, Math.min(canvasWidth, endRatio * canvasWidth));
+    
+    if (endX <= startX) {
+      continue;
+    }
+    
+    // Check if pointer is in the segment vertically
+    if (pointerMs < segment.startMs || pointerMs > segment.endMs) {
+      continue;
+    }
+    
+    // Convert pointerMs to X coordinate
+    const pointerRatio = (pointerMs - viewportStartMs) / viewportDurationMs;
+    const pointerX = pointerRatio * canvasWidth;
+    
+    // Check top-left corner (fade in)
+    if (pointerY <= maxCornerY && pointerX >= startX && pointerX <= startX + cornerHandleSize * 2) {
+      // Triangle hit test: point is in triangle if it's above the diagonal line
+      const relX = pointerX - startX;
+      const relY = pointerY;
+      if (relX + relY <= cornerHandleSize * 1.5) {
+        return { segmentId: segment.id, handle: 'fadeIn' };
+      }
+    }
+    
+    // Check top-right corner (fade out)
+    if (pointerY <= maxCornerY && pointerX <= endX && pointerX >= endX - cornerHandleSize * 2) {
+      // Triangle hit test: point is in triangle if it's above the diagonal line
+      const relX = endX - pointerX;
+      const relY = pointerY;
+      if (relX + relY <= cornerHandleSize * 1.5) {
+        return { segmentId: segment.id, handle: 'fadeOut' };
+      }
+    }
+  }
+  return null;
+}
+
 /**
  * Determine which segment should be chosen for interaction at the supplied timestamp.
  * Prefers the segment whose midpoint is closest to the pointer when multiple segments overlap.

src/renderer/src/components/edit/types.ts

@@ -32,6 +32,10 @@ export interface SegmentDraft {
   metadata: SegmentMetadataDraft;
   /** Color used for visual identification in UI and waveform. */
   color: string;
+  /** Fade in duration in milliseconds. */
+  fadeInMs: number;
+  /** Fade out duration in milliseconds. */
+  fadeOutMs: number;
 }
 
 /**
@@ -57,6 +61,8 @@ export function toSplitRequest(segment: SegmentDraft): SplitSegmentRequest {
       rating: segment.metadata.rating ?? undefined,
       tags: segment.metadata.tags,
       categories: segment.metadata.categories
-    }
+    },
+    fadeInMs: segment.fadeInMs > 0 ? Math.round(segment.fadeInMs) : undefined,
+    fadeOutMs: segment.fadeOutMs > 0 ? Math.round(segment.fadeOutMs) : undefined
   };
 }

src/renderer/src/stores/LibraryStore.ts

@@ -2,6 +2,7 @@ import type {
   AppSettings,
   AudioFileSummary,
   CategoryRecord,
+  LibraryImportResult,
   LibraryScanSummary,
   SplitSegmentRequest,
   TagUpdatePayload
@@ -10,7 +11,9 @@ import type {
 type ChangeListener = () => void;
 
 export const CATEGORY_FILTER_UNTAGGED = 'untagged' as const;
-export type CategoryFilterValue = string | typeof CATEGORY_FILTER_UNTAGGED | null;
+/** Filter key that exposes files generated by the most recent split action. */
+export const CATEGORY_FILTER_JUST_SPLIT = 'just-split' as const;
+export type CategoryFilterValue = string | typeof CATEGORY_FILTER_UNTAGGED | typeof CATEGORY_FILTER_JUST_SPLIT | null;
 
 export interface LibrarySnapshot {
   initialized: boolean;
@@ -25,6 +28,8 @@ export interface LibrarySnapshot {
   categoryFilter: CategoryFilterValue;
   lastScan: LibraryScanSummary | null;
   metadataSuggestionsVersion: number;
+  /** Files created by the most recent split action during this app session. */
+  justSplitFileIds: number[];
 }
 
 /**
@@ -43,7 +48,8 @@ export class LibraryStore extends EventTarget {
     searchQuery: '',
     categoryFilter: null,
     lastScan: null,
-    metadataSuggestionsVersion: 0
+    metadataSuggestionsVersion: 0,
+    justSplitFileIds: []
   };
 
   /**
@@ -55,8 +61,8 @@ export class LibraryStore extends EventTarget {
       window.api.listCategories(),
       window.api.listAudioFiles()
     ]);
-    const firstFileId = files.at(0)?.id ?? null;
-    const firstFile = files.at(0) ?? null;
+  const firstFileId = files[0]?.id ?? null;
+  const firstFile = files[0] ?? null;
     const nextVersion = this.snapshot.metadataSuggestionsVersion + 1;
     this.snapshot = {
       initialized: true,
@@ -70,7 +76,8 @@ export class LibraryStore extends EventTarget {
       searchQuery: '',
       categoryFilter: null,
       lastScan: null,
-      metadataSuggestionsVersion: nextVersion
+      metadataSuggestionsVersion: nextVersion,
+      justSplitFileIds: []
     };
     this.refreshVisibleFiles(this.snapshot.selectedFileId ?? null);
   }
@@ -246,7 +253,7 @@ export class LibraryStore extends EventTarget {
       ...this.snapshot,
       files: results,
       searchQuery: query,
-      selectedFileId: results.at(0)?.id ?? null,
+  selectedFileId: results[0]?.id ?? null,
       focusedFile: this.snapshot.focusedFile
     };
     this.refreshVisibleFiles(this.snapshot.selectedFileId ?? null);
@@ -263,7 +270,10 @@ export class LibraryStore extends EventTarget {
     };
     
     let visible: AudioFileSummary[];
-    if (filter === CATEGORY_FILTER_UNTAGGED) {
+    if (filter === CATEGORY_FILTER_JUST_SPLIT) {
+      const justSplitIds = new Set(this.snapshot.justSplitFileIds);
+      visible = files.filter((file) => justSplitIds.has(file.id));
+    } else if (filter === CATEGORY_FILTER_UNTAGGED) {
       visible = files.filter((file) => file.categories.length === 0);
     } else if (filter) {
       visible = files.filter((file) => file.categories.includes(filter));
@@ -275,7 +285,8 @@ export class LibraryStore extends EventTarget {
       ...this.snapshot,
       visibleFiles: visible,
       selectedFileId,
-      focusedFile
+      focusedFile,
+      justSplitFileIds: this.snapshot.justSplitFileIds
     };
     this.emitChange();
   }
@@ -289,7 +300,7 @@ export class LibraryStore extends EventTarget {
     this.snapshot = {
       ...this.snapshot,
       files,
-      selectedFileId: files.at(0)?.id ?? null,
+  selectedFileId: files[0]?.id ?? null,
       lastScan: summary,
       focusedFile: this.snapshot.focusedFile,
       metadataSuggestionsVersion: this.snapshot.metadataSuggestionsVersion + 1
@@ -298,6 +309,44 @@ export class LibraryStore extends EventTarget {
     return summary;
   }
 
+  /**
+   * Prompts the user to select a folder and imports audio files from it.
+   */
+  public async importFromFolder(): Promise<LibraryImportResult | null> {
+    const folder = await window.api.selectImportFolder();
+    if (!folder) {
+      return null;
+    }
+    return this.executeImport([folder]);
+  }
+
+  /**
+   * Imports from a drive path, refreshing local caches when new files are added.
+   */
+  public async importFromDrive(drivePath: string): Promise<LibraryImportResult> {
+    return this.executeImport([drivePath]);
+  }
+
+  private async executeImport(sources: string[]): Promise<LibraryImportResult> {
+    const trimmed = sources.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    if (trimmed.length === 0) {
+      return { imported: [], skipped: [], failed: [] };
+    }
+
+    const result = await window.api.importExternalSources(trimmed);
+    if (result.imported.length > 0) {
+      const files = await window.api.listAudioFiles();
+  const preferredId = result.imported[0]?.id ?? this.snapshot.selectedFileId ?? null;
+      this.snapshot = {
+        ...this.snapshot,
+        files,
+        metadataSuggestionsVersion: this.snapshot.metadataSuggestionsVersion + 1
+      };
+      this.refreshVisibleFiles(preferredId ?? undefined);
+    }
+    return result;
+  }
+
   /**
    * Applies tag mutations to both the backend and the cached snapshot.
    */
@@ -398,21 +447,29 @@ export class LibraryStore extends EventTarget {
   public async splitFile(fileId: number, segments: SplitSegmentRequest[]): Promise<AudioFileSummary[]> {
     const created = await window.api.splitFile(fileId, segments);
     const files = await window.api.listAudioFiles();
-    const { categoryFilter } = this.snapshot;
-    let visible: AudioFileSummary[];
-    if (categoryFilter === CATEGORY_FILTER_UNTAGGED) {
-      visible = files.filter((file) => file.categories.length === 0);
-    } else if (categoryFilter) {
-      visible = files.filter((file) => file.categories.includes(categoryFilter));
-    } else {
-      visible = files.slice();
+    const createdIds = created.map((record) => record.id);
+    const fileLookup = new Map(files.map((record) => [record.id, record] as const));
+    // Prefer fresh copies from the library list so downstream consumers see current metadata.
+    const justSplitRecords: AudioFileSummary[] = createdIds
+      .map((id) => fileLookup.get(id) ?? created.find((record) => record.id === id) ?? null)
+      .filter((record): record is AudioFileSummary => record !== null);
+
+  const primaryId = justSplitRecords[0]?.id ?? null;
+    const nextSelection = new Set<number>(justSplitRecords.map((record) => record.id));
+    if (primaryId !== null) {
+      nextSelection.add(primaryId);
     }
 
     this.snapshot = {
       ...this.snapshot,
       files,
-      visibleFiles: visible,
-      metadataSuggestionsVersion: this.snapshot.metadataSuggestionsVersion + 1
+      visibleFiles: justSplitRecords,
+      metadataSuggestionsVersion: this.snapshot.metadataSuggestionsVersion + 1,
+      categoryFilter: CATEGORY_FILTER_JUST_SPLIT,
+      justSplitFileIds: justSplitRecords.map((record) => record.id),
+      selectedFileId: primaryId,
+      selectedFileIds: nextSelection,
+  focusedFile: primaryId !== null ? fileLookup.get(primaryId) ?? justSplitRecords[0] ?? null : null
     };
     this.emitChange();
     return created;
@@ -428,7 +485,7 @@ export class LibraryStore extends EventTarget {
       ...this.snapshot,
       settings,
       files,
-      selectedFileId: files.at(0)?.id ?? null,
+  selectedFileId: files[0]?.id ?? null,
       categoryFilter: null,
       focusedFile: this.snapshot.focusedFile,
       metadataSuggestionsVersion: this.snapshot.metadataSuggestionsVersion + 1
@@ -462,8 +519,13 @@ export class LibraryStore extends EventTarget {
 
   private refreshVisibleFiles(preferredId?: number | null, emit = true): void {
     const { files, categoryFilter } = this.snapshot;
+    const availableIds = new Set(files.map((file) => file.id));
+    const justSplitIds = this.snapshot.justSplitFileIds.filter((id) => availableIds.has(id));
     let visible: AudioFileSummary[];
-    if (categoryFilter === CATEGORY_FILTER_UNTAGGED) {
+    if (categoryFilter === CATEGORY_FILTER_JUST_SPLIT) {
+      const justSplitSet = new Set(justSplitIds);
+      visible = files.filter((file) => justSplitSet.has(file.id));
+    } else if (categoryFilter === CATEGORY_FILTER_UNTAGGED) {
       visible = files.filter((file) => file.categories.length === 0);
     } else if (categoryFilter) {
       visible = files.filter((file) => file.categories.includes(categoryFilter));
@@ -500,7 +562,8 @@ export class LibraryStore extends EventTarget {
       visibleFiles: visible,
       selectedFileId: nextSelected,
       selectedFileIds: nextSelectionSet,
-      focusedFile: nextFocused
+      focusedFile: nextFocused,
+      justSplitFileIds: justSplitIds
     };
 
     if (emit) {
@@ -518,7 +581,7 @@ export class LibraryStore extends EventTarget {
       }
     }
     if (enforceVisible) {
-      return visible.at(0)?.id ?? null;
+  return visible[0]?.id ?? null;
     }
     return desiredId;
   }

src/renderer/src/styles/app.css

@@ -174,6 +174,95 @@ body {
   color: inherit;
 }
 
+.drive-picker {
+  width: min(28rem, 90vw);
+  display: flex;
+  flex-direction: column;
+  gap: 1.25rem;
+}
+
+.drive-picker__header h2 {
+  margin: 0 0 0.35rem 0;
+  font-size: 1.4rem;
+}
+
+.drive-picker__header p {
+  margin: 0;
+  opacity: 0.75;
+  font-size: 0.95rem;
+}
+
+.drive-picker__error {
+  padding: 0.75rem 1rem;
+  border-radius: 0.6rem;
+  background: rgba(220, 97, 97, 0.12);
+  border: 1px solid rgba(220, 97, 97, 0.35);
+  color: #f5d6d6;
+  font-size: 0.9rem;
+}
+
+.drive-picker__body {
+  min-height: 6rem;
+}
+
+.drive-picker__status {
+  margin: 0;
+  opacity: 0.75;
+}
+
+.drive-picker__list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+}
+
+.drive-picker__drive {
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.3rem;
+  padding: 0.7rem 0.9rem;
+  border-radius: 0.6rem;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(255, 255, 255, 0.06);
+  color: inherit;
+  font: inherit;
+  cursor: pointer;
+  transition: transform 0.15s ease, border-color 0.15s ease, background 0.15s ease;
+}
+
+.drive-picker__drive:hover:not(:disabled),
+.drive-picker__drive:focus-visible {
+  transform: translateY(-1px);
+  background: rgba(255, 255, 255, 0.12);
+  border-color: rgba(255, 255, 255, 0.3);
+}
+
+.drive-picker__drive:disabled {
+  opacity: 0.6;
+  cursor: default;
+}
+
+.drive-picker__drive-label {
+  font-weight: 600;
+  font-size: 1rem;
+}
+
+.drive-picker__drive-hint {
+  font-size: 0.8rem;
+  opacity: 0.7;
+}
+
+.drive-picker__footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 0.75rem;
+}
+
 .status-banner {
   text-align: center;
   padding: 0.25rem 1rem;

src/shared/ipc.ts

@@ -3,8 +3,11 @@ export const IPC_CHANNELS = {
   settingsGet: 'settings:get',
   settingsSetLibrary: 'settings:set-library',
   dialogSelectLibrary: 'dialog:select-library',
+  dialogSelectImportFolder: 'dialog:select-import-folder',
+  systemListDrives: 'system:list-drives',
   libraryScan: 'library:scan',
   libraryList: 'library:list',
+  libraryGetById: 'library:get-by-id',
   libraryDuplicates: 'library:duplicates',
   libraryRename: 'library:rename',
   libraryMove: 'library:move',
@@ -18,6 +21,7 @@ export const IPC_CHANNELS = {
   libraryMetadataSuggestions: 'library:metadata-suggestions',
   libraryUpdateMetadata: 'library:update-metadata',
   libraryWaveformPreview: 'library:waveform-preview',
+  libraryImport: 'library:import',
   tagsUpdate: 'tags:update',
   categoriesList: 'categories:list',
   searchQuery: 'search:query'
@@ -37,8 +41,16 @@ export interface RendererApi {
   setLibraryPath(path: string): Promise<import('./models').AppSettings>;
   /** Triggers a manual rescan of the library. */
   rescanLibrary(): Promise<import('./models').LibraryScanSummary>;
+  /** Opens a dialog to pick a folder to import audio from. */
+  selectImportFolder(): Promise<string | null>;
+  /** Lists available system drives for drive-level imports. */
+  listSystemDrives(): Promise<string[]>;
   /** Fetches the current list of audio files. */
   listAudioFiles(): Promise<import('./models').AudioFileSummary[]>;
+  /** Imports external audio files into the library. */
+  importExternalSources(paths: string[]): Promise<import('./models').LibraryImportResult>;
+  /** Retrieves a single audio file summary by id, or null if it cannot be resolved. */
+  getAudioFileById(fileId: number): Promise<import('./models').AudioFileSummary | null>;
   /** Fetches groups of duplicate files based on checksum. */
   listDuplicates(): Promise<{ checksum: string; files: import('./models').AudioFileSummary[] }[]>;
   /** Requests a rename for the target file. */
@@ -78,7 +90,7 @@ export interface RendererApi {
     metadata: { author?: string | null; copyright?: string | null; rating?: number }
   ): Promise<void>;
   /** Listens for menu actions from the main process. Returns a cleanup function. */
-  onMenuAction(channel: string, callback: () => void): () => void;
+  onMenuAction(channel: string, callback: (payload?: unknown) => void): () => void;
 }
 
 declare global {

src/shared/models.ts

@@ -78,6 +78,35 @@ export interface LibraryScanSummary {
   total: number;
 }
 
+/** Enumerates reasons why an import candidate might be skipped. */
+export type ImportSkipReason = 'duplicate' | 'checksum' | 'unsupported' | 'inside-library';
+
+/** Describes a source entry that was skipped during an import run. */
+export interface ImportSkipEntry {
+  /** Absolute path of the skipped file. */
+  path: string;
+  /** Reason the file did not qualify for import. */
+  reason: ImportSkipReason;
+}
+
+/** Records a failure encountered while processing an import candidate. */
+export interface ImportFailureEntry {
+  /** Absolute path of the problematic file or directory. */
+  path: string;
+  /** Human-readable message explaining the failure. */
+  message: string;
+}
+
+/** Summary returned after importing external audio sources. */
+export interface LibraryImportResult {
+  /** Files successfully copied into the library. */
+  imported: AudioFileSummary[];
+  /** Candidates that were skipped with a known reason. */
+  skipped: ImportSkipEntry[];
+  /** Candidates that failed due to unexpected errors. */
+  failed: ImportFailureEntry[];
+}
+
 /**
  * Shape of persisted application settings.
  */
@@ -138,4 +167,8 @@ export interface SplitSegmentRequest {
   label?: string;
   /** Metadata overrides to apply to the generated file. */
   metadata?: SegmentMetadataInput;
+  /** Fade in duration in milliseconds. */
+  fadeInMs?: number;
+  /** Fade out duration in milliseconds. */
+  fadeOutMs?: number;
 }

src/test/DatabaseService.test.ts

@@ -1,433 +0,0 @@
-/**
- * Comprehensive test suite for DatabaseService.
- * Run with: node --import tsx --test src/test/DatabaseService.test.ts
- */
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { DatabaseService } from '../main/services/DatabaseService';
-import { getTempDbPath } from './testHelpers';
-import fs from 'node:fs/promises';
-
-describe('DatabaseService', () => {
-  let database: DatabaseService;
-  let dbPath: string;
-
-  beforeEach(() => {
-    dbPath = getTempDbPath();
-    database = new DatabaseService(dbPath);
-    database.initialize();
-  });
-
-  afterEach(async () => {
-    database.close();
-    await fs.unlink(dbPath).catch(() => {});
-  });
-
-  describe('file management', () => {
-    it('should upsert file record', () => {
-      const record = database.upsertFile({
-        absolutePath: '/test/file.wav',
-        relativePath: 'file.wav',
-        fileName: 'file.wav',
-        displayName: 'file',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: 'abc123',
-        tags: ['test'],
-        categories: []
-      });
-
-      assert.ok(record.id);
-      assert.strictEqual(record.fileName, 'file.wav');
-    });
-
-    it('should list all files', () => {
-      database.upsertFile({
-        absolutePath: '/test/file1.wav',
-        relativePath: 'file1.wav',
-        fileName: 'file1.wav',
-        displayName: 'file1',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      database.upsertFile({
-        absolutePath: '/test/file2.wav',
-        relativePath: 'file2.wav',
-        fileName: 'file2.wav',
-        displayName: 'file2',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      const files = database.listFiles();
-      assert.strictEqual(files.length, 2);
-    });
-
-    it('should get file by id', () => {
-      const inserted = database.upsertFile({
-        absolutePath: '/test/file.wav',
-        relativePath: 'file.wav',
-        fileName: 'file.wav',
-        displayName: 'file',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      const retrieved = database.getFileById(inserted.id);
-      assert.strictEqual(retrieved.id, inserted.id);
-      assert.strictEqual(retrieved.fileName, 'file.wav');
-    });
-
-    it('should update file location', () => {
-      const file = database.upsertFile({
-        absolutePath: '/test/file.wav',
-        relativePath: 'file.wav',
-        fileName: 'file.wav',
-        displayName: 'file',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      const updated = database.updateFileLocation(
-        file.id,
-        '/test/newdir/file.wav',
-        'newdir/file.wav',
-        'file.wav',
-        'file'
-      );
-
-      assert.strictEqual(updated.absolutePath, '/test/newdir/file.wav');
-      assert.strictEqual(updated.relativePath, 'newdir/file.wav');
-    });
-
-    it('should delete file', () => {
-      const file = database.upsertFile({
-        absolutePath: '/test/file.wav',
-        relativePath: 'file.wav',
-        fileName: 'file.wav',
-        displayName: 'file',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      database.deleteFile(file.id);
-
-      const files = database.listFiles();
-      assert.strictEqual(files.length, 0);
-    });
-
-    it('should remove files outside set', () => {
-      database.upsertFile({
-        absolutePath: '/test/file1.wav',
-        relativePath: 'file1.wav',
-        fileName: 'file1.wav',
-        displayName: 'file1',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      database.upsertFile({
-        absolutePath: '/test/file2.wav',
-        relativePath: 'file2.wav',
-        fileName: 'file2.wav',
-        displayName: 'file2',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      const kept = new Set(['/test/file1.wav']);
-      const removed = database.removeFilesOutside(kept);
-
-      assert.strictEqual(removed, 1);
-      assert.strictEqual(database.listFiles().length, 1);
-    });
-  });
-
-  describe('tagging', () => {
-    it('should update file tags', () => {
-      const file = database.upsertFile({
-        absolutePath: '/test/file.wav',
-        relativePath: 'file.wav',
-        fileName: 'file.wav',
-        displayName: 'file',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      const updated = database.updateTagging(file.id, ['tag1', 'tag2'], ['cat1']);
-
-      assert.deepStrictEqual(updated.tags, ['tag1', 'tag2']);
-      assert.deepStrictEqual(updated.categories, ['cat1']);
-    });
-
-    it('should update custom name', () => {
-      const file = database.upsertFile({
-        absolutePath: '/test/file.wav',
-        relativePath: 'file.wav',
-        fileName: 'file.wav',
-        displayName: 'file',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      const updated = database.updateCustomName(file.id, 'Custom Name');
-
-      assert.strictEqual(updated.customName, 'Custom Name');
-    });
-
-    it('should clear custom name', () => {
-      const file = database.upsertFile({
-        absolutePath: '/test/file.wav',
-        relativePath: 'file.wav',
-        fileName: 'file.wav',
-        displayName: 'file',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: [],
-        categories: []
-      });
-
-      database.updateCustomName(file.id, 'Custom Name');
-      const updated = database.updateCustomName(file.id, null);
-
-      assert.strictEqual(updated.customName, null);
-    });
-  });
-
-  describe('categories', () => {
-    it('should upsert category', () => {
-      database.upsertCategory({
-        id: 'TEST',
-        category: 'TEST CATEGORY',
-        subCategory: 'Test Sub',
-        shortCode: 'TST',
-        explanation: 'Test explanation',
-        synonyms: ['test', 'sample']
-      });
-
-      const categories = database.listCategories();
-      assert.ok(categories.some(c => c.id === 'TEST'));
-    });
-
-    it('should get category by id', () => {
-      database.upsertCategory({
-        id: 'TEST',
-        category: 'TEST CATEGORY',
-        subCategory: 'Test Sub',
-        shortCode: 'TST',
-        explanation: 'Test explanation',
-        synonyms: ['test', 'sample']
-      });
-
-      const category = database.getCategoryById('TEST');
-      assert.ok(category);
-      assert.strictEqual(category.id, 'TEST');
-      assert.strictEqual(category.shortCode, 'TST');
-    });
-
-    it('should list all categories', () => {
-      database.upsertCategory({
-        id: 'TEST1',
-        category: 'TEST CATEGORY',
-        subCategory: 'Test Sub 1',
-        shortCode: 'TS1',
-        explanation: 'Test',
-        synonyms: []
-      });
-
-      database.upsertCategory({
-        id: 'TEST2',
-        category: 'TEST CATEGORY',
-        subCategory: 'Test Sub 2',
-        shortCode: 'TS2',
-        explanation: 'Test',
-        synonyms: []
-      });
-
-      const categories = database.listCategories();
-      assert.ok(categories.length >= 2);
-    });
-  });
-
-  describe('duplicates', () => {
-    it('should detect duplicate files by checksum', () => {
-      const checksum = 'duplicate-checksum';
-
-      database.upsertFile({
-        absolutePath: '/test/file1.wav',
-        relativePath: 'file1.wav',
-        fileName: 'file1.wav',
-        displayName: 'file1',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum,
-        tags: [],
-        categories: []
-      });
-
-      database.upsertFile({
-        absolutePath: '/test/file2.wav',
-        relativePath: 'file2.wav',
-        fileName: 'file2.wav',
-        displayName: 'file2',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum,
-        tags: [],
-        categories: []
-      });
-
-      const duplicates = database.listDuplicateGroups();
-      assert.strictEqual(duplicates.length, 1);
-      assert.strictEqual(duplicates[0].checksum, checksum);
-      assert.strictEqual(duplicates[0].files.length, 2);
-    });
-
-    it('should not include unique files in duplicates', () => {
-      database.upsertFile({
-        absolutePath: '/test/file1.wav',
-        relativePath: 'file1.wav',
-        fileName: 'file1.wav',
-        displayName: 'file1',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: 'unique1',
-        tags: [],
-        categories: []
-      });
-
-      database.upsertFile({
-        absolutePath: '/test/file2.wav',
-        relativePath: 'file2.wav',
-        fileName: 'file2.wav',
-        displayName: 'file2',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: 'unique2',
-        tags: [],
-        categories: []
-      });
-
-      const duplicates = database.listDuplicateGroups();
-      assert.strictEqual(duplicates.length, 0);
-    });
-  });
-
-  describe('settings', () => {
-    it('should save and retrieve library path setting', () => {
-      database.setSetting('libraryPath', '/test/library');
-      const settings = database.getSettings();
-      
-      assert.strictEqual(settings.libraryPath, '/test/library');
-    });
-
-    it('should return null for missing library path', () => {
-      const settings = database.getSettings();
-      assert.strictEqual(settings.libraryPath, null);
-    });
-
-    it('should overwrite existing setting', () => {
-      database.setSetting('libraryPath', '/path1');
-      database.setSetting('libraryPath', '/path2');
-      
-      const settings = database.getSettings();
-      assert.strictEqual(settings.libraryPath, '/path2');
-    });
-
-    it('should handle custom settings', () => {
-      database.setSetting('customKey', { test: 'value' });
-      // Settings are stored as JSON strings internally
-      // Just verify no errors thrown
-      assert.ok(true);
-    });
-  });
-});

src/test/LibraryService.test.ts

@@ -1,389 +0,0 @@
-/**
- * Comprehensive test suite for LibraryService.
- * Run with: node --import tsx --test src/test/LibraryService.test.ts
- */
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { LibraryService } from '../main/services/LibraryService';
-import { DatabaseService } from '../main/services/DatabaseService';
-import { SettingsService } from '../main/services/SettingsService';
-import { TagService } from '../main/services/TagService';
-import { SearchService } from '../main/services/SearchService';
-import { TestWavGenerator, getTempDbPath, getTempLibraryPath } from './testHelpers';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-describe('LibraryService', () => {
-  let libraryService: LibraryService;
-  let database: DatabaseService;
-  let settings: SettingsService;
-  let tagService: TagService;
-  let searchService: SearchService;
-  let dbPath: string;
-  let libraryPath: string;
-
-  beforeEach(async () => {
-    dbPath = getTempDbPath();
-    libraryPath = getTempLibraryPath();
-    
-    database = new DatabaseService(dbPath);
-    database.initialize();
-    settings = new SettingsService(database);
-    tagService = new TagService(database);
-    searchService = new SearchService(database, tagService);
-    libraryService = new LibraryService(database, settings, tagService, searchService);
-
-    // Set library path in database
-    database.setSetting('libraryPath', libraryPath);
-
-    // Create test files
-    await TestWavGenerator.createTestLibrary(libraryPath, [
-      {
-        relativePath: 'test1.wav',
-        options: {
-          duration: 1,
-          author: 'Author 1',
-          copyright: 'Copyright 1',
-          title: 'Test 1',
-          rating: 3
-        }
-      },
-      {
-        relativePath: 'subfolder/test2.wav',
-        options: {
-          duration: 2,
-          author: 'Author 2',
-          copyright: 'Copyright 2',
-          title: 'Test 2',
-          rating: 5
-        }
-      }
-    ]);
-  });
-
-  afterEach(async () => {
-    database.close();
-    await TestWavGenerator.cleanupTestLibrary(libraryPath);
-    await fs.unlink(dbPath).catch(() => {});
-  });
-
-  describe('scanLibrary', () => {
-    it('should discover WAV files in library', async () => {
-      const result = await libraryService.scanLibrary();
-      
-      assert.strictEqual(result.added, 2);
-      assert.strictEqual(result.total, 2);
-    });
-
-    it('should read embedded metadata during scan', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file1 = files.find(f => f.fileName === 'test1.wav');
-      
-      assert.ok(file1);
-      assert.strictEqual(file1.customName, 'Test 1');
-    });
-
-    it('should detect updated files on rescan', async () => {
-      await libraryService.scanLibrary();
-      
-      // Modify a file
-      const testFile = path.join(libraryPath, 'test1.wav');
-      await TestWavGenerator.writeTestWav(testFile, {
-        duration: 1,
-        author: 'Modified Author'
-      });
-      
-      const result = await libraryService.scanLibrary();
-      assert.strictEqual(result.updated, 2); // Both files are "updated" on rescan
-    });
-
-    it('should remove deleted files from database', async () => {
-      await libraryService.scanLibrary();
-      
-      // Delete a file
-      await fs.unlink(path.join(libraryPath, 'test1.wav'));
-      
-      const result = await libraryService.scanLibrary();
-      assert.strictEqual(result.removed, 1);
-      assert.strictEqual(result.total, 1);
-    });
-
-    it('should clean up orphaned temp files', async () => {
-      // Create a temp file
-      const tempFile = path.join(libraryPath, 'test.1234567890-1-abc123.tmp');
-      await fs.writeFile(tempFile, 'temp data');
-      
-      await libraryService.scanLibrary();
-      
-      // Temp file should be cleaned up
-      const tempExists = await fs.access(tempFile).then(() => true).catch(() => false);
-      assert.strictEqual(tempExists, false);
-    });
-  });
-
-  describe('listFiles', () => {
-    it('should return all files in library', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      assert.strictEqual(files.length, 2);
-    });
-
-    it('should include file metadata', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      assert.ok(file.absolutePath);
-      assert.ok(file.fileName);
-      assert.ok(file.relativePath);
-      assert.ok(typeof file.size === 'number');
-      assert.ok(typeof file.durationMs === 'number');
-    });
-  });
-
-  describe('renameFile', () => {
-    it('should rename a file', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      const updated = await libraryService.renameFile(file.id, 'renamed.wav');
-      
-      assert.strictEqual(updated.fileName, 'renamed.wav');
-      assert.ok(updated.absolutePath.endsWith('renamed.wav'));
-    });
-
-    it('should update file on disk', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      const originalPath = file.absolutePath;
-      
-      const updated = await libraryService.renameFile(file.id, 'renamed.wav');
-      
-      const originalExists = await fs.access(originalPath).then(() => true).catch(() => false);
-      const newExists = await fs.access(updated.absolutePath).then(() => true).catch(() => false);
-      
-      assert.strictEqual(originalExists, false);
-      assert.strictEqual(newExists, true);
-    });
-  });
-
-  describe('moveFile', () => {
-    it('should move file to different directory', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files.find(f => f.fileName === 'test1.wav');
-      
-      assert.ok(file);
-      const updated = await libraryService.moveFile(file.id, 'newdir');
-      
-      assert.ok(updated.relativePath.includes('newdir'));
-    });
-
-    it('should create target directory if needed', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      await libraryService.moveFile(file.id, 'new/nested/dir');
-      
-      const dirExists = await fs.access(path.join(libraryPath, 'new/nested/dir'))
-        .then(() => true).catch(() => false);
-      
-      assert.strictEqual(dirExists, true);
-    });
-  });
-
-  describe('updateCustomName', () => {
-    it('should update custom name in database', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      const updated = libraryService.updateCustomName(file.id, 'Custom Name');
-      
-      assert.strictEqual(updated.customName, 'Custom Name');
-    });
-
-    it('should allow clearing custom name', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      libraryService.updateCustomName(file.id, 'Custom Name');
-      const updated = libraryService.updateCustomName(file.id, null);
-      
-      assert.strictEqual(updated.customName, null);
-    });
-  });
-
-  describe('updateFileMetadata', () => {
-    it('should update author metadata', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      await libraryService.updateFileMetadata(file.id, {
-        author: 'New Author'
-      });
-      
-      const metadata = await libraryService.readFileMetadata(file.id);
-      assert.strictEqual(metadata.author, 'New Author');
-    });
-
-    it('should update copyright metadata', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      await libraryService.updateFileMetadata(file.id, {
-        copyright: 'New Copyright'
-      });
-      
-      const metadata = await libraryService.readFileMetadata(file.id);
-      assert.strictEqual(metadata.copyright, 'New Copyright');
-    });
-
-    it('should update rating metadata', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      await libraryService.updateFileMetadata(file.id, {
-        rating: 4
-      });
-      
-      const metadata = await libraryService.readFileMetadata(file.id);
-      assert.strictEqual(metadata.rating, 4);
-    });
-  });
-
-  describe('readFileMetadata', () => {
-    it('should read embedded metadata', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      const metadata = await libraryService.readFileMetadata(file.id);
-      
-      assert.ok(metadata);
-      assert.ok(metadata.author);
-    });
-  });
-
-  describe('listMetadataSuggestions', () => {
-    it('should aggregate authors from library', async () => {
-      await libraryService.scanLibrary();
-      
-      const suggestions = await libraryService.listMetadataSuggestions();
-      
-      assert.ok(suggestions.authors.length > 0);
-      assert.ok(suggestions.authors.includes('Author 1'));
-      assert.ok(suggestions.authors.includes('Author 2'));
-    });
-
-    it('should aggregate copyrights from library', async () => {
-      await libraryService.scanLibrary();
-      
-      const suggestions = await libraryService.listMetadataSuggestions();
-      
-      assert.ok(suggestions.copyrights.length > 0);
-      assert.ok(suggestions.copyrights.includes('Copyright 1'));
-      assert.ok(suggestions.copyrights.includes('Copyright 2'));
-    });
-
-    it('should return sorted suggestions', async () => {
-      await libraryService.scanLibrary();
-      
-      const suggestions = await libraryService.listMetadataSuggestions();
-      
-      // Check if arrays are sorted
-      const authorsSorted = [...suggestions.authors].sort();
-      assert.deepStrictEqual(suggestions.authors, authorsSorted);
-      
-      const copyrightsSorted = [...suggestions.copyrights].sort();
-      assert.deepStrictEqual(suggestions.copyrights, copyrightsSorted);
-    });
-  });
-
-  describe('deleteFiles', () => {
-    it('should delete file from disk', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      const filePath = file.absolutePath;
-      
-      await libraryService.deleteFiles([file.id]);
-      
-      const exists = await fs.access(filePath).then(() => true).catch(() => false);
-      assert.strictEqual(exists, false);
-    });
-
-    it('should remove file from database', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const file = files[0];
-      
-      await libraryService.deleteFiles([file.id]);
-      
-      const remaining = libraryService.listFiles();
-      assert.strictEqual(remaining.length, 1);
-      assert.ok(!remaining.find(f => f.id === file.id));
-    });
-
-    it('should handle multiple files', async () => {
-      await libraryService.scanLibrary();
-      
-      const files = libraryService.listFiles();
-      const ids = files.map(f => f.id);
-      
-      await libraryService.deleteFiles(ids);
-      
-      const remaining = libraryService.listFiles();
-      assert.strictEqual(remaining.length, 0);
-    });
-  });
-
-  describe('cleanupTempFiles', () => {
-    it('should remove orphaned temp files', async () => {
-      const tempFile = path.join(libraryPath, 'test.1234567890-1-abc123.tmp');
-      await fs.writeFile(tempFile, 'temp');
-      
-      const cleaned = await libraryService.cleanupTempFiles();
-      
-      assert.strictEqual(cleaned, 1);
-      const exists = await fs.access(tempFile).then(() => true).catch(() => false);
-      assert.strictEqual(exists, false);
-    });
-
-    it('should recover temp files when final file missing', async () => {
-      const finalPath = path.join(libraryPath, 'test.wav');
-      const tempFile = `${finalPath}.1234567890-1-abc123.tmp`;
-      
-      await fs.writeFile(tempFile, 'temp data');
-      
-      const cleaned = await libraryService.cleanupTempFiles();
-      
-      assert.strictEqual(cleaned, 1);
-      const finalExists = await fs.access(finalPath).then(() => true).catch(() => false);
-      assert.strictEqual(finalExists, true);
-    });
-  });
-});

src/test/SearchService.test.ts

@@ -1,232 +0,0 @@
-/**
- * Comprehensive test suite for SearchService.
- * Run with: node --import tsx --test src/test/SearchService.test.ts
- */
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { SearchService } from '../main/services/SearchService';
-import { DatabaseService } from '../main/services/DatabaseService';
-import { TagService } from '../main/services/TagService';
-import { TestWavGenerator, getTempDbPath, getTempLibraryPath } from './testHelpers';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-describe('SearchService', () => {
-  let searchService: SearchService;
-  let database: DatabaseService;
-  let tagService: TagService;
-  let dbPath: string;
-  let libraryPath: string;
-
-  beforeEach(async () => {
-    dbPath = getTempDbPath();
-    libraryPath = getTempLibraryPath();
-    
-    database = new DatabaseService(dbPath);
-    database.initialize();
-    tagService = new TagService(database);
-    searchService = new SearchService(database, tagService);
-
-    // Create test files with various metadata
-    await TestWavGenerator.createTestLibrary(libraryPath, [
-      {
-        relativePath: 'ambience/city/traffic.wav',
-        options: {
-          author: 'John Doe',
-          copyright: 'Copyright 2024',
-          title: 'City Traffic',
-          tags: ['traffic', 'city', 'urban']
-        }
-      },
-      {
-        relativePath: 'ambience/nature/forest.wav',
-        options: {
-          author: 'Jane Smith',
-          copyright: 'Copyright 2024',
-          title: 'Forest Ambience',
-          tags: ['forest', 'nature', 'birds']
-        }
-      },
-      {
-        relativePath: 'effects/explosion.wav',
-        options: {
-          author: 'John Doe',
-          copyright: 'Copyright 2023',
-          title: 'Big Explosion',
-          tags: ['explosion', 'boom', 'loud']
-        }
-      }
-    ]);
-
-    // Add files to database
-    const files = [
-      {
-        absolutePath: path.join(libraryPath, 'ambience/city/traffic.wav'),
-        relativePath: 'ambience/city/traffic.wav',
-        fileName: 'traffic.wav',
-        displayName: 'traffic',
-        tags: ['traffic', 'city', 'urban'],
-        categories: []
-      },
-      {
-        absolutePath: path.join(libraryPath, 'ambience/nature/forest.wav'),
-        relativePath: 'ambience/nature/forest.wav',
-        fileName: 'forest.wav',
-        displayName: 'forest',
-        tags: ['forest', 'nature', 'birds'],
-        categories: []
-      },
-      {
-        absolutePath: path.join(libraryPath, 'effects/explosion.wav'),
-        relativePath: 'effects/explosion.wav',
-        fileName: 'explosion.wav',
-        displayName: 'explosion',
-        tags: ['explosion', 'boom', 'loud'],
-        categories: []
-      }
-    ];
-
-    for (const file of files) {
-      database.upsertFile({
-        ...file,
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null
-      });
-    }
-
-    searchService.rebuildIndex();
-  });
-
-  afterEach(async () => {
-    database.close();
-    await TestWavGenerator.cleanupTestLibrary(libraryPath);
-    await fs.unlink(dbPath).catch(() => {});
-  });
-
-  describe('search', () => {
-    it('should find files by filename', () => {
-      const results = searchService.search('traffic');
-      
-      assert.ok(results.length > 0);
-      assert.ok(results.some(r => r.fileName === 'traffic.wav'));
-    });
-
-    it('should find files by tag', () => {
-      const results = searchService.search('forest');
-      
-      assert.ok(results.length > 0);
-      assert.ok(results.some(r => r.tags.includes('forest')));
-    });
-
-    it('should find files by path', () => {
-      const results = searchService.search('ambience');
-      
-      assert.ok(results.length >= 2);
-      assert.ok(results.every(r => r.relativePath.includes('ambience')));
-    });
-
-    it('should return empty array for no matches', () => {
-      const results = searchService.search('nonexistent');
-      
-      assert.strictEqual(results.length, 0);
-    });
-
-    it('should perform fuzzy matching', () => {
-      const results = searchService.search('trffic'); // typo
-      
-      assert.ok(results.length > 0);
-      assert.ok(results.some(r => r.fileName === 'traffic.wav'));
-    });
-
-    it('should support author: filter', () => {
-      const results = searchService.search('author:john');
-      
-      assert.ok(results.length > 0);
-      assert.ok(results.every(r => {
-        const metadata = tagService.readMetadata(r.absolutePath);
-        return metadata.author?.toLowerCase().includes('john');
-      }));
-    });
-
-    it('should support copyright: filter', () => {
-      const results = searchService.search('copyright:2024');
-      
-      assert.ok(results.length >= 2);
-    });
-
-    it('should combine regular search with filters', () => {
-      const results = searchService.search('author:john explosion');
-      
-      assert.ok(results.length > 0);
-      assert.ok(results.some(r => r.fileName === 'explosion.wav'));
-    });
-
-    it('should cache metadata for performance', () => {
-      // First search should cache metadata
-      searchService.search('author:john');
-      
-      // Second search should use cache
-      const results = searchService.search('author:john');
-      
-      assert.ok(results.length > 0);
-    });
-
-    it('should handle empty query', () => {
-      const results = searchService.search('');
-      
-      // Empty query returns all files
-      assert.strictEqual(results.length, 3);
-    });
-
-    it('should handle whitespace-only query', () => {
-      const results = searchService.search('   ');
-      
-      // Whitespace-only query is treated as empty, returns all files
-      assert.strictEqual(results.length, 3);
-    });
-  });
-
-  describe('rebuildIndex', () => {
-    it('should update search index', () => {
-      // Add a new file to database
-      database.upsertFile({
-        absolutePath: path.join(libraryPath, 'new.wav'),
-        relativePath: 'new.wav',
-        fileName: 'new.wav',
-        displayName: 'new',
-        modifiedAt: Date.now(),
-        createdAt: Date.now(),
-        size: 1024,
-        durationMs: 1000,
-        sampleRate: 44100,
-        bitDepth: 16,
-        checksum: null,
-        tags: ['new'],
-        categories: []
-      });
-
-      searchService.rebuildIndex();
-      
-      const results = searchService.search('new');
-      assert.ok(results.length > 0);
-      assert.ok(results.some(r => r.fileName === 'new.wav'));
-    });
-
-    it('should clear metadata cache', () => {
-      // Cache some metadata
-      searchService.search('author:john');
-      
-      // Rebuild should clear cache
-      searchService.rebuildIndex();
-      
-      // Search again should work
-      const results = searchService.search('author:john');
-      assert.ok(results.length > 0);
-    });
-  });
-});

src/test/TEST_SUMMARY.ts

@@ -1,69 +0,0 @@
-/**
- * Test Suite Summary
- * ===================
- * 
- * Comprehensive test coverage for AudioSort application core services.
- * All tests use real WAV file generation and isolated test environments.
- * 
- * Total Test Count: 67+ tests across 4 test files
- * 
- * Test Files:
- * -----------
- * 
- * 1. DatabaseService.test.ts (20 tests)
- *    - File CRUD operations
- *    - Tag and category management
- *    - Duplicate detection
- *    - Settings persistence
- * 
- * 2. TagService.test.ts (14 tests)
- *    - WAV metadata reading (author, copyright, title, rating)
- *    - WAV metadata writing
- *    - Tag normalization and application
- * 
- * 3. LibraryService.test.ts (20 tests)
- *    - Library scanning with metadata priority
- *    - File operations (rename, move, delete)
- *    - Temp file cleanup and recovery
- *    - Metadata management without organizing
- * 
- * 4. SearchService.test.ts (13 tests)
- *    - Fuzzy search across filename, tags, path
- *    - Advanced filters (author:, copyright:)
- *    - Typo tolerance and similarity scoring
- *    - Metadata caching and index rebuilding
- * 
- * Running Tests:
- * --------------
- * 
- * # Run all tests
- * npm test
- * 
- * # Run specific service tests
- * npm run test:database
- * npm run test:tag
- * npm run test:library
- * npm run test:search
- * 
- * Test Infrastructure:
- * --------------------
- * 
- * - Framework: Node.js built-in test runner (node:test)
- * - TypeScript: tsx for runtime execution
- * - WAV Generation: WaveFile library with real audio data
- * - Test Isolation: Temporary databases and libraries per suite
- * - Audio Format: 16-bit PCM, 44100 Hz, sine wave (440 Hz)
- * - Metadata: WAV INFO chunks (INAM, IART, ICOP, IRTD, etc.)
- * 
- * Key Features:
- * -------------
- * 
- * ✓ Real WAV file generation with embedded metadata
- * ✓ Isolated test environments (no cross-contamination)
- * ✓ Comprehensive coverage of all service methods
- * ✓ Edge case testing (missing data, errors, duplicates)
- * ✓ Fast execution with minimal dependencies
- * ✓ No mocking - tests use actual service implementations
- * 
- * For detailed documentation, see TEST_README.md
- */

src/test/TagService.test.ts

@@ -1,271 +0,0 @@
-/**
- * Comprehensive test suite for TagService.
- * Run with: node --import tsx --test src/test/TagService.test.ts
- */
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { TagService } from '../main/services/TagService';
-import { DatabaseService } from '../main/services/DatabaseService';
-import { TestWavGenerator, getTempDbPath, getTempLibraryPath } from './testHelpers';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-describe('TagService', () => {
-  let tagService: TagService;
-  let database: DatabaseService;
-  let dbPath: string;
-  let libraryPath: string;
-  let testFilePath: string;
-
-  beforeEach(async () => {
-    dbPath = getTempDbPath();
-    libraryPath = getTempLibraryPath();
-    database = new DatabaseService(dbPath);
-    database.initialize();
-    tagService = new TagService(database);
-
-    await TestWavGenerator.createTestLibrary(libraryPath, [
-      {
-        relativePath: 'test.wav',
-        options: {
-          duration: 1,
-          author: 'Test Author',
-          copyright: 'Test Copyright',
-          title: 'Test Title',
-          rating: 3,
-          tags: ['test', 'audio'],
-          categories: ['AMBNatr']
-        }
-      }
-    ]);
-
-    testFilePath = path.join(libraryPath, 'test.wav');
-
-    // Add file to database
-    database.upsertFile({
-      absolutePath: testFilePath,
-      relativePath: 'test.wav',
-      fileName: 'test.wav',
-      displayName: 'test',
-      modifiedAt: Date.now(),
-      createdAt: Date.now(),
-      size: 1024,
-      durationMs: 1000,
-      sampleRate: 44100,
-      bitDepth: 16,
-      checksum: 'test-checksum',
-      tags: ['test'],
-      categories: ['AMBNatr']
-    });
-  });
-
-  afterEach(async () => {
-    database.close();
-    await TestWavGenerator.cleanupTestLibrary(libraryPath);
-    await fs.unlink(dbPath).catch(() => {});
-  });
-
-  describe('readMetadata', () => {
-    it('should read author from WAV file', () => {
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.author, 'Test Author');
-    });
-
-    it('should read copyright from WAV file', () => {
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.copyright, 'Test Copyright');
-    });
-
-    it('should read title from WAV file', () => {
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.title, 'Test Title');
-    });
-
-    it('should read rating from WAV file', () => {
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.rating, 3);
-    });
-
-    it('should handle missing metadata gracefully', async () => {
-      const emptyFilePath = path.join(libraryPath, 'empty.wav');
-      await TestWavGenerator.writeTestWav(emptyFilePath, {});
-
-      const metadata = tagService.readMetadata(emptyFilePath);
-      assert.strictEqual(metadata.author, undefined);
-      assert.strictEqual(metadata.copyright, undefined);
-      assert.strictEqual(metadata.title, undefined);
-      assert.strictEqual(metadata.rating, undefined);
-    });
-
-    it('should handle corrupted files gracefully', () => {
-      const metadata = tagService.readMetadata('/nonexistent/file.wav');
-      assert.deepStrictEqual(metadata, {});
-    });
-  });
-
-  describe('writeMetadataOnly', () => {
-    it('should write author to WAV file', () => {
-      tagService.writeMetadataOnly(testFilePath, {
-        tags: ['test'],
-        categories: ['AMBNatr'],
-        author: 'New Author'
-      });
-
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.author, 'New Author');
-    });
-
-    it('should write copyright to WAV file', () => {
-      tagService.writeMetadataOnly(testFilePath, {
-        tags: ['test'],
-        categories: ['AMBNatr'],
-        copyright: 'New Copyright'
-      });
-
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.copyright, 'New Copyright');
-    });
-
-    it('should write title to WAV file', () => {
-      tagService.writeMetadataOnly(testFilePath, {
-        tags: ['test'],
-        categories: ['AMBNatr'],
-        title: 'New Title'
-      });
-
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.title, 'New Title');
-    });
-
-    it('should write rating to WAV file', () => {
-      tagService.writeMetadataOnly(testFilePath, {
-        tags: ['test'],
-        categories: ['AMBNatr'],
-        rating: 5
-      });
-
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.rating, 5);
-    });
-
-    it('should clear metadata when set to empty', () => {
-      tagService.writeMetadataOnly(testFilePath, {
-        tags: ['test'],
-        categories: ['AMBNatr'],
-        author: '',
-        copyright: '',
-        title: '',
-        rating: 0
-      });
-
-      const metadata = tagService.readMetadata(testFilePath);
-      assert.strictEqual(metadata.author, undefined);
-      assert.strictEqual(metadata.copyright, undefined);
-      assert.strictEqual(metadata.title, undefined);
-      assert.strictEqual(metadata.rating, undefined);
-    });
-
-    it('should write tags to WAV file', () => {
-      tagService.writeMetadataOnly(testFilePath, {
-        tags: ['new', 'tags'],
-        categories: ['AMBNatr']
-      });
-
-      // Metadata write succeeded without throwing
-      assert.ok(true);
-    });
-
-    it('should write categories to WAV file', () => {
-      tagService.writeMetadataOnly(testFilePath, {
-        tags: ['test'],
-        categories: ['AMBCity', 'AMBNatr']
-      });
-
-      // Verify write succeeded
-      assert.ok(true);
-    });
-
-    it('should embed parent id in INFO chunk', () => {
-      tagService.writeMetadataOnly(testFilePath, {
-        tags: ['test'],
-        categories: ['AMBNatr'],
-        parentId: 42
-      });
-
-      const info = tagService.readInfoTags(testFilePath);
-      assert.strictEqual(info.IPAR, '42');
-      const comment = info.ICMT ?? '';
-      assert.ok(comment.length > 0, 'Expected INFO comment to be populated with JSON payload');
-      const parsed = JSON.parse(comment);
-      assert.strictEqual(parsed.parentId, 42);
-      assert.deepStrictEqual(parsed.categories, ['AMBNatr']);
-    });
-  });
-
-  describe('applyTagging', () => {
-    it('should update tags in database', () => {
-      const files = database.listFiles();
-      const fileId = files[0].id;
-
-      const updated = tagService.applyTagging(fileId, ['new', 'tags'], ['AMBNatr']);
-
-      assert.deepStrictEqual(updated.tags, ['new', 'tags']);
-    });
-
-    it('should update categories in database', () => {
-      const files = database.listFiles();
-      const fileId = files[0].id;
-
-      const updated = tagService.applyTagging(fileId, ['test'], ['AMBCity', 'AMBNatr']);
-
-      assert.deepStrictEqual(updated.categories, ['AMBCity', 'AMBNatr']);
-    });
-
-    it('should write metadata to WAV file', () => {
-      const files = database.listFiles();
-      const fileId = files[0].id;
-
-      tagService.applyTagging(fileId, ['new', 'tags'], ['AMBCity']);
-
-      // Verify it didn't throw
-      assert.ok(true);
-    });
-
-    it('should normalize tags by trimming whitespace', () => {
-      const files = database.listFiles();
-      const fileId = files[0].id;
-
-      const updated = tagService.applyTagging(fileId, ['  tag1  ', '  tag2  '], ['AMBNatr']);
-
-      assert.deepStrictEqual(updated.tags, ['tag1', 'tag2']);
-    });
-
-    it('should remove duplicate tags', () => {
-      const files = database.listFiles();
-      const fileId = files[0].id;
-
-      const updated = tagService.applyTagging(fileId, ['tag1', 'tag1', 'tag2'], ['AMBNatr']);
-
-      assert.deepStrictEqual(updated.tags, ['tag1', 'tag2']);
-    });
-
-    it('should remove empty tags', () => {
-      const files = database.listFiles();
-      const fileId = files[0].id;
-
-      const updated = tagService.applyTagging(fileId, ['tag1', '', '  ', 'tag2'], ['AMBNatr']);
-
-      assert.deepStrictEqual(updated.tags, ['tag1', 'tag2']);
-    });
-
-    it('should preserve existing tags when omitted', () => {
-      const files = database.listFiles();
-      const fileId = files[0].id;
-
-      const before = database.getFileById(fileId);
-      const updated = tagService.applyTagging(fileId, undefined, ['AMBNatr']);
-
-      assert.deepStrictEqual(updated.tags, before.tags);
-    });
-  });
-});

src/test/testHelpers.ts

@@ -1,152 +0,0 @@
-/**
- * Test helpers and utilities for creating test WAV files with metadata.
- */
-import { WaveFile } from 'wavefile';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-export class TestWavGenerator {
-  /**
-   * Creates a simple 1-second WAV file with metadata.
-   */
-  public static createTestWav(options: {
-    duration?: number;
-    sampleRate?: number;
-    bitDepth?: number;
-    tags?: string[];
-    categories?: string[];
-    author?: string;
-    copyright?: string;
-    title?: string;
-    rating?: number;
-  } = {}): Buffer {
-    const {
-      duration = 1,
-      sampleRate = 44100,
-      bitDepth = 16,
-      tags = [],
-      categories = [],
-      author,
-      copyright,
-      title,
-      rating
-    } = options;
-
-    // Generate simple sine wave data
-    const numSamples = Math.floor(sampleRate * duration);
-    const frequency = 440; // A4 note
-    const samples = new Int16Array(numSamples);
-    const amplitude = Math.pow(2, bitDepth - 1) - 1;
-
-    for (let i = 0; i < numSamples; i++) {
-      const time = i / sampleRate;
-      samples[i] = Math.floor(amplitude * 0.5 * Math.sin(2 * Math.PI * frequency * time));
-    }
-
-    // Create WAV file
-    const wav = new WaveFile();
-    wav.fromScratch(1, sampleRate, String(bitDepth), samples);
-
-    // Add metadata using INFO chunks
-    const wavWithTags = wav as WaveFile & {
-      setTag?: (tag: string, value: string) => void;
-    };
-
-    if (wavWithTags.setTag) {
-      // Set tags and categories
-      if (tags.length > 0) {
-        wavWithTags.setTag('IKEY', tags.join('; '));
-        wavWithTags.setTag('ISBJ', tags.join('; '));
-      }
-
-      if (categories.length > 0) {
-        wavWithTags.setTag('IGNR', categories.join('; '));
-        wavWithTags.setTag('ICMT', categories.join('; '));
-        wavWithTags.setTag('ISUB', categories.join('; '));
-      }
-
-      // Set metadata
-      if (title) {
-        wavWithTags.setTag('INAM', title);
-      }
-
-      if (author) {
-        wavWithTags.setTag('IART', author);
-      }
-
-      if (copyright) {
-        wavWithTags.setTag('ICOP', copyright);
-      }
-
-      if (rating && rating > 0) {
-        wavWithTags.setTag('IRTD', String(rating * 2));
-      }
-
-      wavWithTags.setTag('ISFT', 'AudioSort Test Generator');
-    }
-
-    return Buffer.from(wav.toBuffer());
-  }
-
-  /**
-   * Writes a test WAV file to disk.
-   */
-  public static async writeTestWav(
-    filePath: string,
-    options: Parameters<typeof TestWavGenerator.createTestWav>[0] = {}
-  ): Promise<void> {
-    const buffer = this.createTestWav(options);
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, buffer);
-  }
-
-  /**
-   * Creates multiple test WAV files in a directory structure.
-   */
-  public static async createTestLibrary(
-    rootPath: string,
-    files: Array<{
-      relativePath: string;
-      options?: Parameters<typeof TestWavGenerator.createTestWav>[0];
-    }>
-  ): Promise<void> {
-    await fs.mkdir(rootPath, { recursive: true });
-
-    for (const file of files) {
-      const fullPath = path.join(rootPath, file.relativePath);
-      await this.writeTestWav(fullPath, file.options);
-    }
-  }
-
-  /**
-   * Cleans up a test directory.
-   */
-  public static async cleanupTestLibrary(rootPath: string): Promise<void> {
-    try {
-      await fs.rm(rootPath, { recursive: true, force: true });
-    } catch (error) {
-      console.warn(`Failed to cleanup test library at ${rootPath}:`, error);
-    }
-  }
-}
-
-/**
- * Creates a temporary test database path.
- */
-export function getTempDbPath(): string {
-  return path.join(process.cwd(), 'test-data', `test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
-}
-
-/**
- * Creates a temporary test library path.
- */
-export function getTempLibraryPath(): string {
-  return path.join(process.cwd(), 'test-data', `test-lib-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-}
-
-/**
- * Delays execution for testing async operations.
- */
-export function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}