chore: bump version to 0.3.0

- Modified MainApp.ts to resolve the path for UCS.csv from the 'data' directory.
- Deleted the unused test.wav file to clean up the repository.

.github/workflows/build.yml

@@ -1,6 +1,9 @@
 name: Build/release
 
-on: push
+on:
+  push:
+    tags:
+      - 'v*'
 
 jobs:
   release:

.gitignore

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

README.md

@@ -1,6 +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)
 
@@ -26,8 +27,18 @@ 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
@@ -62,7 +73,7 @@ Download the latest `AudioSort Setup.exe` from the [Releases](../../releases) pa
 #### Setup
 ```bash
 # Clone the repository
-git clone <your-repo-url>
+git clone https://github.com/litruv/AudioSort/
 cd AudioSort
 
 # Install dependencies
@@ -118,8 +129,8 @@ AudioSort/
 │   │       └── hooks/       # Custom React hooks
 │   ├── preload/           # Electron preload scripts
 │   └── shared/            # Shared types and IPC definitions
-├── data/                  # User data directory (created at runtime)
+├── data/
-├── UCS.csv               # Universal Category System catalog
+│   └── UCS.csv           # Universal Category System catalog
 └── repoimages/           # Documentation assets
 ```
 
@@ -130,21 +141,11 @@ AudioSort/
 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
-```
-
 ## Configuration
 
 ### Build Configuration
@@ -157,4 +158,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,7 @@
 {
   "name": "audio-sort",
-  "version": "0.1.0",
+  "version": "0.3.0",
-  "description": "Electron audio sorting application with fuzzy search, tagging, and library management for WAV files.",
+  "description": "Electron audio sorting application with fuzzy search, tagging, library management, and advanced waveform editing with audio splitting capabilities for WAV files.",
   "main": "dist/main/main/index.js",
   "type": "commonjs",
   "scripts": {
@@ -16,19 +16,15 @@
     "start": "cross-env NODE_ENV=production electron ./dist/main/main/index.js",
     "pack": "npm run build && electron-builder --dir",
     "dist": "npm run build && electron-builder",
-    "dist:win": "npm run build && electron-builder --win",
+    "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"
   },
   "dependencies": {
-    "better-sqlite3": "^9.4.5",
+    "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",
+  "standardized-audio-context": "^25.3.12",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "wavefile": "^11.0.0"
@@ -41,7 +37,7 @@
     "@vitejs/plugin-react": "^4.3.3",
     "concurrently": "^8.2.2",
     "cross-env": "^7.0.3",
-    "electron": "^29.4.4",
+    "electron": "^32.0.0",
     "electron-builder": "^26.0.12",
     "tree-kill": "^1.2.2",
     "tsx": "^4.15.7",
@@ -53,7 +49,7 @@
     "productName": "AudioSort",
     "files": [
       "dist/**/*",
-      "UCS.csv"
+      "data/**/*"
     ],
     "directories": {
       "output": "release"
@@ -68,8 +64,8 @@
     },
     "extraResources": [
       {
-        "from": "UCS.csv",
+        "from": "data/UCS.csv",
-        "to": "UCS.csv"
+        "to": "data/UCS.csv"
       }
     ]
   }

src/main/MainApp.ts

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { app, BrowserWindow, dialog, ipcMain, nativeTheme, Menu } from 'electron';
 import type { IpcMainInvokeEvent } from 'electron';
 import { IPC_CHANNELS } from '../shared/ipc';
-import { TagUpdatePayload } from '../shared/models';
+import { SplitSegmentRequest, TagUpdatePayload } from '../shared/models';
 import { DatabaseService } from './services/DatabaseService';
 import { LibraryService } from './services/LibraryService';
 import { SearchService } from './services/SearchService';
@@ -41,7 +41,7 @@ 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();
 
@@ -141,6 +141,7 @@ export class MainApp {
   ipcMain.removeHandler(IPC_CHANNELS.libraryMetadata);
   ipcMain.removeHandler(IPC_CHANNELS.libraryMetadataSuggestions);
   ipcMain.removeHandler(IPC_CHANNELS.libraryUpdateMetadata);
+   ipcMain.removeHandler(IPC_CHANNELS.librarySplit);
     ipcMain.removeHandler(IPC_CHANNELS.libraryWaveformPreview);
     ipcMain.removeHandler(IPC_CHANNELS.tagsUpdate);
     ipcMain.removeHandler(IPC_CHANNELS.categoriesList);
@@ -186,16 +187,18 @@ export class MainApp {
       this.mainWindow = null;
     });
 
-    const devServerUrl = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env?.VITE_DEV_SERVER_URL;
+    const devServerUrl = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env
+      ?.VITE_DEV_SERVER_URL;
     if (devServerUrl) {
       this.mainWindow.loadURL(devServerUrl).catch((error: unknown) => {
+        // eslint-disable-next-line no-console -- Logging is useful during development to diagnose boot issues.
         console.error('Failed to load renderer URL', error);
       });
     } else {
       const rendererIndex = this.resolveRendererIndex();
-      this.mainWindow.loadFile(rendererIndex).catch((error: unknown) => {
+      this.mainWindow
-        console.error('Failed to load renderer bundle', error);
+        .loadFile(rendererIndex)
-      });
+        .catch((error: unknown) => console.error('Failed to load renderer bundle', error));
     }
   }
 
@@ -222,6 +225,9 @@ export class MainApp {
 
     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)
@@ -239,7 +245,11 @@ export class MainApp {
 
     ipcMain.handle(
       IPC_CHANNELS.libraryOrganize,
-      async (_event: IpcMainInvokeEvent, fileId: number, metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }) =>
+      async (
+        _event: IpcMainInvokeEvent,
+        fileId: number,
+        metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }
+      ) =>
       this.requireLibrary().organizeFile(fileId, metadata)
     );
 
@@ -257,6 +267,12 @@ export class MainApp {
       this.requireLibrary().deleteFiles(fileIds)
     );
 
+    ipcMain.handle(
+      IPC_CHANNELS.librarySplit,
+      async (_event: IpcMainInvokeEvent, fileId: number, segments: SplitSegmentRequest[]) =>
+        this.requireLibrary().splitFile(fileId, segments)
+    );
+
     ipcMain.handle(IPC_CHANNELS.libraryBuffer, async (_event: IpcMainInvokeEvent, fileId: number) =>
       this.requireLibrary().getAudioBuffer(fileId)
     );
@@ -283,7 +299,11 @@ export class MainApp {
 
     ipcMain.handle(
       IPC_CHANNELS.libraryUpdateMetadata,
-      async (_event: IpcMainInvokeEvent, fileId: number, metadata: { author?: string | null; copyright?: string | null; rating?: number }) =>
+      async (
+        _event: IpcMainInvokeEvent,
+        fileId: number,
+        metadata: { author?: string | null; copyright?: string | null; rating?: number }
+      ) =>
         this.requireLibrary().updateFileMetadata(fileId, metadata)
     );
   }

src/main/services/DatabaseService.ts

@@ -33,6 +33,8 @@ export interface FileRecordInput {
   tags?: string[];
   /** Optional category payload (stored as JSON string). */
   categories?: string[];
+  /** Optional parent file reference when generated from another file. */
+  parentFileId?: number | null;
 }
 
 export interface FileRecordRow extends AudioFileSummary {}
@@ -89,7 +91,8 @@ export class DatabaseService {
         bit_depth,
         checksum,
         tags_json,
-        categories_json
+        categories_json,
+        parent_file_id
       ) VALUES (
         @absolutePath,
         @relativePath,
@@ -103,7 +106,8 @@ export class DatabaseService {
         @bitDepth,
         @checksum,
         @tagsJson,
-        @categoriesJson
+        @categoriesJson,
+        @parentFileId
       )
       ON CONFLICT(absolute_path) DO UPDATE SET
         library_relative_path = excluded.library_relative_path,
@@ -117,7 +121,8 @@ export class DatabaseService {
         bit_depth = excluded.bit_depth,
         checksum = excluded.checksum,
         tags_json = CASE WHEN files.tags_json = '[]' THEN excluded.tags_json ELSE files.tags_json END,
-        categories_json = CASE WHEN files.categories_json = '[]' THEN excluded.categories_json ELSE files.categories_json END
+        categories_json = CASE WHEN files.categories_json = '[]' THEN excluded.categories_json ELSE files.categories_json END,
+        parent_file_id = CASE WHEN excluded.parent_file_id IS NOT NULL THEN excluded.parent_file_id ELSE files.parent_file_id END
       RETURNING *`
     );
 
@@ -134,7 +139,8 @@ export class DatabaseService {
       bitDepth: record.bitDepth,
       checksum: record.checksum,
       tagsJson: JSON.stringify(record.tags ?? []),
-      categoriesJson: JSON.stringify(record.categories ?? [])
+      categoriesJson: JSON.stringify(record.categories ?? []),
+      parentFileId: record.parentFileId ?? null
     }) as DbRow | undefined;
 
     if (!row) {
@@ -145,22 +151,35 @@ export class DatabaseService {
   }
 
   /**
-   * Updates the stored tags and categories for a file.
+   * Updates the stored tags and/or categories for a file.
+   * When a field is omitted it remains unchanged.
    */
-  public updateTagging(fileId: number, tags: string[], categories: string[]): AudioFileSummary {
+  public updateTagging(fileId: number, tags?: string[], categories?: string[]): AudioFileSummary {
     const connection = this.requireDb();
+    const updates: string[] = [];
+    const parameters: Record<string, unknown> = { id: fileId };
+
+    if (tags !== undefined) {
+      updates.push('tags_json = @tags');
+      parameters.tags = JSON.stringify(tags);
+    }
+
+    if (categories !== undefined) {
+      updates.push('categories_json = @categories');
+      parameters.categories = JSON.stringify(categories);
+    }
+
+    if (updates.length === 0) {
+      return this.getFileById(fileId);
+    }
+
     const statement = connection.prepare(
       `UPDATE files
-         SET tags_json = @tags,
+         SET ${updates.join(', ')}
-             categories_json = @categories
        WHERE id = @id
        RETURNING *`
     );
-    const row = statement.get({
+    const row = statement.get(parameters) as DbRow | undefined;
-      id: fileId,
-      tags: JSON.stringify(tags),
-      categories: JSON.stringify(categories)
-    }) as DbRow | undefined;
     if (!row) {
       throw new Error(`File with id ${fileId} not found`);
     }
@@ -408,6 +427,7 @@ export class DatabaseService {
       sampleRate: row.sample_rate === null ? null : (row.sample_rate as number),
       bitDepth: row.bit_depth === null ? null : (row.bit_depth as number),
       checksum: typeof row.checksum === 'string' ? (row.checksum as string) : null,
+      parentFileId: typeof row.parent_file_id === 'number' ? (row.parent_file_id as number) : null,
       tags: this.parseJsonArray(row.tags_json),
       categories: this.parseJsonArray(row.categories_json),
       customName: typeof row.custom_name === 'string' ? (row.custom_name as string) : null
@@ -444,7 +464,8 @@ export class DatabaseService {
         bit_depth INTEGER,
         checksum TEXT,
         tags_json TEXT NOT NULL DEFAULT '[]',
-        categories_json TEXT NOT NULL DEFAULT '[]'
+        categories_json TEXT NOT NULL DEFAULT '[]',
+        parent_file_id INTEGER REFERENCES files(id)
       );
       CREATE INDEX IF NOT EXISTS idx_files_display_name ON files(display_name);
       CREATE INDEX IF NOT EXISTS idx_files_modified ON files(modified_at);
@@ -478,6 +499,7 @@ export class DatabaseService {
     this.addColumnIfMissing(connection, 'files', 'created_at', 'INTEGER');
     this.addColumnIfMissing(connection, 'files', 'checksum', 'TEXT');
     this.addColumnIfMissing(connection, 'files', 'custom_name', 'TEXT');
+  this.addColumnIfMissing(connection, 'files', 'parent_file_id', 'INTEGER');
 
     // Create checksum index after ensuring column exists
     connection.exec('CREATE INDEX IF NOT EXISTS idx_files_checksum ON files(checksum)');

src/main/services/LibraryService.ts

@@ -4,7 +4,7 @@ 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, TagUpdatePayload } from '../../shared/models';
+import { AppSettings, AudioBufferPayload, AudioFileSummary, CategoryRecord, LibraryScanSummary, SplitSegmentRequest, TagUpdatePayload } from '../../shared/models';
 import { DatabaseService, FileRecordInput } from './DatabaseService';
 import { SettingsService } from './SettingsService';
 import { TagService } from './TagService';
@@ -29,9 +29,9 @@ export class LibraryService {
   private readonly metadataFailures = new Set<string>();
   private readonly checksumFailures = new Set<string>();
   private readonly organization: OrganizationService;
-  private metadataSuggestionCache: { authors: Set<string>; copyrights: Set<string> } | null = null;
+  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;
   public constructor(
     private readonly database: DatabaseService,
     private readonly settings: SettingsService,
@@ -84,11 +84,12 @@ 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));
   const existingByChecksum = new Map(existing.filter((file) => file.checksum).map((file) => [file.checksum!, file] as const));
+  const discoveredByPath = new Map<string, AudioFileSummary>();
 
     const pattern = ['**/*.wav', '**/*.wave'];
     const absolutePaths = await fg(pattern, {
@@ -117,9 +118,29 @@ export class LibraryService {
       const knownFile = knownByPath ?? knownByChecksum ?? null;
       const wasKnown = knownFile !== null;
       
-      // Read embedded WAV metadata (author, copyright, rating, title)
+      // Read embedded WAV metadata (author, copyright, rating, title, parentId)
       const embeddedMetadata = this.tagService.readMetadata(absolutePath);
       
+      let parentFileId = knownFile?.parentFileId ?? null;
+      
+      // First try embedded metadata parentId
+      if (parentFileId === null && embeddedMetadata.parentId !== undefined) {
+        parentFileId = embeddedMetadata.parentId;
+      }
+      
+      // Fall back to filename pattern matching for segments
+      if (parentFileId === null) {
+        const segmentMatch = fileName.match(/^(.*)_segment\d+(\.[^.]+)$/i);
+        if (segmentMatch) {
+          const parentFileName = `${segmentMatch[1]}${segmentMatch[2]}`;
+          const parentAbsolutePath = path.join(path.dirname(absolutePath), parentFileName);
+          const parentRecord = existingByPath.get(parentAbsolutePath) ?? discoveredByPath.get(parentAbsolutePath) ?? null;
+          if (parentRecord) {
+            parentFileId = parentRecord.id;
+          }
+        }
+      }
+
       const record: FileRecordInput = {
         absolutePath,
         relativePath,
@@ -133,14 +154,36 @@ export class LibraryService {
         bitDepth: metadata.bitDepth,
         checksum,
         tags: metadata.tags.length > 0 ? metadata.tags : (knownFile?.tags ?? []),
-        categories: metadata.categories.length > 0 ? metadata.categories : (knownFile?.categories ?? [])
+        categories: metadata.categories.length > 0 ? metadata.categories : (knownFile?.categories ?? []),
+        parentFileId
       };
       const upserted = this.database.upsertFile(record);
       
       // Update custom name from embedded title if present, otherwise keep existing
       const customName = embeddedMetadata.title?.trim() || knownFile?.customName || null;
-      if (customName !== upserted.customName) {
+      const finalRecord = customName !== upserted.customName
-        this.database.updateCustomName(upserted.id, customName);
+        ? this.database.updateCustomName(upserted.id, customName)
+        : upserted;
+
+      existingByPath.set(absolutePath, finalRecord);
+      if (checksum) {
+        existingByChecksum.set(checksum, finalRecord);
+      }
+      discoveredByPath.set(absolutePath, finalRecord);
+
+      if (parentFileId !== null) {
+        const embeddedParent = embeddedMetadata.parentId ?? null;
+        if (embeddedParent === null || embeddedParent !== parentFileId) {
+          this.tagService.writeMetadataOnly(absolutePath, {
+            tags: finalRecord.tags,
+            categories: finalRecord.categories,
+            title: customName ?? embeddedMetadata.title ?? finalRecord.displayName,
+            author: embeddedMetadata.author ?? null,
+            rating: embeddedMetadata.rating,
+            copyright: embeddedMetadata.copyright ?? null,
+            parentId: parentFileId
+          });
+        }
       }
       
       if (wasKnown) {
@@ -171,6 +214,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).
    */
@@ -292,7 +349,7 @@ export class LibraryService {
    */
   public async getWaveformPreview(fileId: number, pointCount = 160): Promise<{ samples: number[]; rms: number }> {
     const record = this.database.getFileById(fileId);
-    const effectivePoints = Math.min(Math.max(pointCount ?? 160, 32), 512);
+  const effectivePoints = Math.min(Math.max(pointCount ?? 160, 32), 16384);
     const cacheHit = this.waveformPreviewCache.get(fileId);
     if (cacheHit && cacheHit.modifiedAt === record.modifiedAt && cacheHit.pointCount === effectivePoints) {
       return { samples: cacheHit.samples, rms: cacheHit.rms };
@@ -302,7 +359,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) {
@@ -378,7 +435,6 @@ export class LibraryService {
       return this.organizeFile(payload.fileId, {
         customName: updated.customName ?? undefined,
         author: metadataSnapshot.author?.trim() || undefined,
-        copyright: metadataSnapshot.copyright?.trim() || undefined,
         rating: metadataSnapshot.rating ?? undefined
       });
     }
@@ -435,7 +491,7 @@ export class LibraryService {
    */
   public async organizeFile(
     fileId: number,
-    metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }
+    metadata: { customName?: string | null; author?: string | null; rating?: number }
   ): Promise<AudioFileSummary> {
     const record = this.database.getFileById(fileId);
     const category = this.organization.getPrimaryCategory(record);
@@ -503,9 +559,7 @@ export class LibraryService {
       
       // Merge with new metadata (only update fields that are provided)
       const requestedAuthor = this.normaliseMetadataInput(metadata.author);
-      const requestedCopyright = this.normaliseMetadataInput(metadata.copyright);
       const mergedAuthor = requestedAuthor !== undefined ? requestedAuthor : existing.author ?? null;
-      const mergedCopyright = requestedCopyright !== undefined ? requestedCopyright : existing.copyright ?? null;
       const mergedRating = metadata.rating !== undefined ? metadata.rating : existing.rating;
       
       this.tagService.writeMetadataOnly(updatedRecord.absolutePath, {
@@ -513,16 +567,14 @@ export class LibraryService {
         categories: updatedRecord.categories,
         title: effectiveCustomName,
         author: mergedAuthor,
-        copyright: mergedCopyright,
+        rating: mergedRating,
-        rating: mergedRating
+        copyright: existing.copyright ?? null,
+        parentId: updatedRecord.parentFileId ?? null
       });
 
       // Update suggestions cache for any metadata that was provided
       if (typeof mergedAuthor === 'string' && mergedAuthor.length > 0) {
-        this.updateMetadataSuggestionsCache(mergedAuthor, undefined);
+        this.updateMetadataSuggestionsCache(mergedAuthor);
-      }
-      if (typeof mergedCopyright === 'string' && mergedCopyright.length > 0) {
-        this.updateMetadataSuggestionsCache(undefined, mergedCopyright);
       }
 
       this.resetMetadataSuggestionsCache();
@@ -602,9 +654,7 @@ export class LibraryService {
     
     // Merge with new metadata (only update fields that are provided)
   const movedAuthor = this.normaliseMetadataInput(metadata.author);
-  const movedCopyright = this.normaliseMetadataInput(metadata.copyright);
   const mergedAuthor = movedAuthor !== undefined ? movedAuthor : existing.author ?? null;
-  const mergedCopyright = movedCopyright !== undefined ? movedCopyright : existing.copyright ?? null;
     const mergedRating = metadata.rating !== undefined ? metadata.rating : existing.rating;
     
     // Write tags, categories, and additional metadata to the organized file
@@ -613,16 +663,14 @@ export class LibraryService {
       categories: updated.categories,
       title: effectiveCustomName,
       author: mergedAuthor,
-      copyright: mergedCopyright,
+      rating: mergedRating,
-      rating: mergedRating
+      copyright: existing.copyright ?? null,
+      parentId: updated.parentFileId ?? null
     });
 
     // Update suggestions cache for any metadata that was provided
     if (typeof mergedAuthor === 'string' && mergedAuthor.length > 0) {
-      this.updateMetadataSuggestionsCache(mergedAuthor, undefined);
+      this.updateMetadataSuggestionsCache(mergedAuthor);
-    }
-    if (typeof mergedCopyright === 'string' && mergedCopyright.length > 0) {
-      this.updateMetadataSuggestionsCache(undefined, mergedCopyright);
     }
 
     this.resetMetadataSuggestionsCache();
@@ -649,6 +697,381 @@ export class LibraryService {
     this.search.rebuildIndex();
   }
 
+  /**
+   * Splits an audio file into multiple segments, writing each segment to disk and registering it in the library.
+   */
+  public async splitFile(fileId: number, requestSegments: SplitSegmentRequest[]): Promise<AudioFileSummary[]> {
+    if (!Array.isArray(requestSegments) || requestSegments.length === 0) {
+      return [];
+    }
+
+    const record = this.database.getFileById(fileId);
+    const fileBuffer = await fs.readFile(record.absolutePath);
+  const wave = new WaveFile(fileBuffer);
+  const format = (wave as WaveFile & { fmt?: { sampleRate?: number; bitsPerSample?: number } }).fmt;
+    const rawSamples = wave.getSamples(false, Float64Array) as Float64Array | Float64Array[];
+    const channels = Array.isArray(rawSamples) ? rawSamples : [rawSamples];
+    if (channels.length === 0 || channels[0].length === 0) {
+      throw new Error('Unable to split file: no audio data available.');
+    }
+
+  const sampleRate = format?.sampleRate ?? record.sampleRate ?? null;
+    if (!sampleRate) {
+      throw new Error('Unable to split file: missing sample rate information.');
+    }
+
+    const sourceSampleCount = channels[0].length;
+    const totalDurationMs = Math.round((sourceSampleCount / sampleRate) * 1000);
+    const bitDepthNumeric = (() => {
+  const explicit = format?.bitsPerSample;
+      if (typeof explicit === 'number' && Number.isFinite(explicit) && explicit > 0) {
+        return explicit;
+      }
+      if (typeof record.bitDepth === 'number' && Number.isFinite(record.bitDepth) && record.bitDepth > 0) {
+        return record.bitDepth;
+      }
+      const parsedFromText = Number.parseInt(typeof wave.bitDepth === 'string' ? wave.bitDepth : '', 10);
+      return Number.isFinite(parsedFromText) && parsedFromText > 0 ? parsedFromText : null;
+    })();
+    const bitDepthText = (() => {
+      if (typeof wave.bitDepth === 'string' && wave.bitDepth.trim().length > 0) {
+        return wave.bitDepth.trim();
+      }
+      if (typeof bitDepthNumeric === 'number') {
+        return bitDepthNumeric.toString();
+      }
+      return '16';
+    })();
+    const container = (wave as WaveFile & { container?: string }).container ?? 'RIFF';
+
+  let originalMetadata: { author?: string | null; rating?: number; title?: string | null; copyright?: string | null } = {};
+    try {
+      const metadata = this.tagService.readMetadata(record.absolutePath);
+      originalMetadata = {
+        author: metadata.author ?? null,
+        rating: metadata.rating ?? undefined,
+        title: metadata.title ?? null,
+        copyright: metadata.copyright ?? null
+      };
+    } catch (error) {
+      console.warn('Failed to read original metadata before splitting', error);
+    }
+
+    const normalizedSegments = requestSegments
+      .map((segment) => {
+        const startMs = Number.isFinite(segment.startMs) ? Math.max(0, Math.min(Math.floor(segment.startMs), totalDurationMs)) : 0;
+        const endMs = Number.isFinite(segment.endMs) ? Math.max(0, Math.min(Math.floor(segment.endMs), totalDurationMs)) : startMs;
+        const safeEnd = Math.max(startMs + 1, endMs);
+        return {
+          startMs,
+          endMs: safeEnd,
+          label: segment.label?.trim() ?? undefined,
+          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)
+      .sort((a, b) => a.startMs - b.startMs);
+
+    if (normalizedSegments.length === 0) {
+      return [];
+    }
+
+    const libraryRoot = this.settings.ensureLibraryPath();
+    const sourceDirectory = path.dirname(record.absolutePath);
+    const relativeFolder = path.dirname(record.relativePath);
+    const folderForJoin = relativeFolder === '.' ? '' : relativeFolder;
+    const baseName = path.basename(record.fileName, path.extname(record.fileName));
+    const usedNames = new Set<string>();
+    let sequence = 1;
+    const created: AudioFileSummary[] = [];
+
+    for (const segment of normalizedSegments) {
+      const startSample = Math.max(0, Math.min(Math.floor((segment.startMs / 1000) * sampleRate), sourceSampleCount - 1));
+      const endSample = Math.max(
+        startSample + 1,
+        Math.min(Math.floor((segment.endMs / 1000) * sampleRate), sourceSampleCount)
+      );
+      if (endSample <= startSample) {
+        continue;
+      }
+
+  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;
+      const segmentBytes = Buffer.from(nextWave.toBuffer());
+
+      // Determine the segment name part - use label if available, otherwise use sequence
+      let segmentNamePart = '';
+      if (segment.label) {
+        const sanitized = this.organization.sanitizeCustomName(segment.label);
+        if (sanitized) {
+          segmentNamePart = sanitized;
+        }
+      }
+      
+      let segmentFileName = '';
+      let segmentAbsolutePath = '';
+      for (let attempt = 0; attempt < 1000; attempt += 1) {
+        let candidateName: string;
+        if (segmentNamePart) {
+          // Use label-based name, with optional suffix for duplicates
+          if (attempt === 0) {
+            candidateName = `${baseName}_${segmentNamePart}.wav`;
+          } else {
+            candidateName = `${baseName}_${segmentNamePart}_${this.organization.formatSequenceNumber(attempt)}.wav`;
+          }
+        } else {
+          // Fallback to sequential numbering
+          const suffix = this.organization.formatSequenceNumber(sequence);
+          sequence += 1;
+          candidateName = `${baseName}_segment${suffix}.wav`;
+        }
+        
+        if (usedNames.has(candidateName)) {
+          continue;
+        }
+        const candidatePath = path.join(sourceDirectory, candidateName);
+        const exists = await this.pathExists(candidatePath);
+        if (exists) {
+          continue;
+        }
+        segmentFileName = candidateName;
+        segmentAbsolutePath = candidatePath;
+        usedNames.add(candidateName);
+        break;
+      }
+
+      if (!segmentFileName || !segmentAbsolutePath) {
+        throw new Error('Failed to allocate filename for split segment.');
+      }
+
+      this.assertWithinLibrary(libraryRoot, segmentAbsolutePath);
+      await fs.writeFile(segmentAbsolutePath, segmentBytes);
+      const stats = await fs.stat(segmentAbsolutePath);
+      const checksum = createHash('md5').update(segmentBytes).digest('hex');
+      const relativePath = this.toLibraryRelativePath(folderForJoin, segmentFileName);
+      const durationMs = Math.round(((endSample - startSample) / sampleRate) * 1000);
+
+      const resolvedTagsSource = segment.metadata?.tags ?? record.tags;
+      const resolvedCategoriesSource = segment.metadata?.categories ?? record.categories;
+      const resolvedTags = Array.isArray(resolvedTagsSource) ? resolvedTagsSource.slice() : record.tags.slice();
+      const resolvedCategories = Array.isArray(resolvedCategoriesSource)
+        ? resolvedCategoriesSource.slice()
+        : record.categories.slice();
+      const fileRecord = this.database.upsertFile({
+        absolutePath: segmentAbsolutePath,
+        relativePath,
+        fileName: segmentFileName,
+        displayName: path.basename(segmentFileName, '.wav'),
+        modifiedAt: stats.mtimeMs,
+        createdAt: Number.isNaN(stats.birthtimeMs) ? null : stats.birthtimeMs,
+        size: stats.size,
+        durationMs,
+        sampleRate,
+        bitDepth: bitDepthNumeric,
+        checksum,
+        tags: resolvedTags,
+        categories: resolvedCategories,
+        parentFileId: record.id
+      });
+
+      const resolvedCustomName = segment.metadata?.customName !== undefined
+        ? this.normaliseMetadataInput(segment.metadata.customName)
+        : segment.label !== undefined
+          ? this.normaliseMetadataInput(segment.label)
+          : record.customName ?? null;
+      const updatedRecord = resolvedCustomName !== fileRecord.customName
+        ? this.database.updateCustomName(fileRecord.id, resolvedCustomName ?? null)
+        : fileRecord;
+
+      const resolvedAuthor = segment.metadata?.author !== undefined
+        ? this.normaliseMetadataInput(segment.metadata.author)
+        : this.normaliseMetadataInput(originalMetadata.author ?? null);
+      const resolvedRating = segment.metadata?.rating !== undefined
+        ? segment.metadata.rating ?? undefined
+        : originalMetadata.rating;
+
+      this.tagService.writeMetadataOnly(segmentAbsolutePath, {
+        tags: resolvedTags,
+        categories: resolvedCategories,
+        title: resolvedCustomName ?? updatedRecord.displayName,
+        author: resolvedAuthor ?? undefined,
+        rating: resolvedRating,
+        copyright: originalMetadata.copyright ?? null,
+        parentId: record.id
+      });
+
+      if (typeof resolvedAuthor === 'string' && resolvedAuthor.length > 0) {
+        this.updateMetadataSuggestionsCache(resolvedAuthor);
+      }
+
+      this.waveformPreviewCache.delete(updatedRecord.id);
+      created.push(updatedRecord);
+    }
+
+    this.waveformPreviewCache.delete(record.id);
+    this.resetMetadataSuggestionsCache();
+    this.search.rebuildIndex();
+
+    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.
    */
@@ -666,20 +1089,20 @@ export class LibraryService {
   }
 
   /**
-   * Reads embedded metadata from a WAV file and returns author, copyright, title, and rating.
+   * Reads embedded metadata from a WAV file and returns author, title, and rating.
    */
-  public async readFileMetadata(fileId: number): Promise<{ author?: string; copyright?: string; title?: string; rating?: number }> {
+  public async readFileMetadata(fileId: number): Promise<{ author?: string; title?: string; rating?: number }> {
     const record = this.database.getFileById(fileId);
     const metadata = this.tagService.readMetadata(record.absolutePath);
-    this.updateMetadataSuggestionsCache(metadata.author, metadata.copyright);
+    this.updateMetadataSuggestionsCache(metadata.author);
     return metadata;
   }
 
   /**
-   * Updates metadata (author, copyright, rating) without organizing the file.
+   * Updates metadata (author, rating) without organizing the file.
    * Only writes to the WAV INFO chunk, doesn't move or rename the file.
    */
-  public async updateFileMetadata(fileId: number, metadata: { author?: string | null; copyright?: string | null; rating?: number }): Promise<void> {
+  public async updateFileMetadata(fileId: number, metadata: { author?: string | null; rating?: number }): Promise<void> {
     const record = this.database.getFileById(fileId);
     
     // Read existing metadata from the WAV file
@@ -687,14 +1110,14 @@ export class LibraryService {
     
     // Merge with new metadata (only update fields that are provided)
     const requestedAuthor = this.normaliseMetadataInput(metadata.author);
-    const requestedCopyright = this.normaliseMetadataInput(metadata.copyright);
     const mergedMetadata = {
       tags: record.tags,
       categories: record.categories,
       title: record.customName ?? existing.title,
       author: requestedAuthor !== undefined ? requestedAuthor : existing.author ?? null,
-      copyright: requestedCopyright !== undefined ? requestedCopyright : existing.copyright ?? null,
+      rating: metadata.rating !== undefined ? metadata.rating : existing.rating,
-      rating: metadata.rating !== undefined ? metadata.rating : existing.rating
+      copyright: existing.copyright ?? null,
+      parentId: record.parentFileId ?? null
     };
     
     // Write merged metadata to the WAV file
@@ -702,10 +1125,7 @@ export class LibraryService {
 
     // Update suggestions cache
     if (typeof mergedMetadata.author === 'string' && mergedMetadata.author.length > 0) {
-      this.updateMetadataSuggestionsCache(mergedMetadata.author, undefined);
+      this.updateMetadataSuggestionsCache(mergedMetadata.author);
-    }
-    if (typeof mergedMetadata.copyright === 'string' && mergedMetadata.copyright.length > 0) {
-      this.updateMetadataSuggestionsCache(undefined, mergedMetadata.copyright);
     }
 
     this.waveformPreviewCache.delete(fileId);
@@ -715,10 +1135,9 @@ export class LibraryService {
   /**
    * Returns distinct metadata suggestions aggregated from the library.
    */
-  public async listMetadataSuggestions(): Promise<{ authors: string[]; copyrights: string[] }> {
+  public async listMetadataSuggestions(): Promise<{ authors: string[] }> {
     if (!this.metadataSuggestionCache) {
       const authors = new Set<string>();
-      const copyrights = new Set<string>();
       const files = this.database.listFiles();
 
       for (const file of files) {
@@ -727,9 +1146,6 @@ export class LibraryService {
           if (metadata.author) {
             this.addSuggestionValue(authors, metadata.author);
           }
-          if (metadata.copyright) {
-            this.addSuggestionValue(copyrights, metadata.copyright);
-          }
         } catch (error) {
           if (!this.metadataFailures.has(file.absolutePath)) {
             this.metadataFailures.add(file.absolutePath);
@@ -739,12 +1155,11 @@ export class LibraryService {
         }
       }
 
-      this.metadataSuggestionCache = { authors, copyrights };
+      this.metadataSuggestionCache = { authors };
     }
 
     return {
-      authors: Array.from(this.metadataSuggestionCache.authors).sort((a, b) => a.localeCompare(b)),
+      authors: Array.from(this.metadataSuggestionCache.authors).sort((a, b) => a.localeCompare(b))
-      copyrights: Array.from(this.metadataSuggestionCache.copyrights).sort((a, b) => a.localeCompare(b))
     };
   }
 
@@ -769,16 +1184,13 @@ export class LibraryService {
     return trimmed.length > 0 ? trimmed : null;
   }
 
-  private updateMetadataSuggestionsCache(author?: string | null, copyright?: string | null): void {
+  private updateMetadataSuggestionsCache(author?: string | null): void {
     if (!this.metadataSuggestionCache) {
       return;
     }
     if (author) {
       this.addSuggestionValue(this.metadataSuggestionCache.authors, author);
     }
-    if (copyright) {
-      this.addSuggestionValue(this.metadataSuggestionCache.copyrights, copyright);
-    }
   }
 
   /**

src/main/services/SearchService.ts

@@ -8,14 +8,13 @@ import { TagService } from './TagService';
  */
 interface CachedMetadata {
   author?: string;
-  copyright?: string;
 }
 
 /**
  * Represents a structured filter derived from the freeform query.
  */
 interface AdvancedFilter {
-  field: 'author' | 'copyright';
+  field: 'author';
   value: string;
 }
 
@@ -119,7 +118,7 @@ export class SearchService {
   }
 
   /**
-   * Pulls out author/copyright filters and returns the remaining free text query.
+   * Pulls out author filters and returns the remaining free text query.
    */
   private extractAdvancedFilters(query: string): { filters: AdvancedFilter[]; remainingQuery: string } {
     const tokens = query.split(/\s+/);
@@ -135,13 +134,6 @@ export class SearchService {
         }
         continue;
       }
-      if (lower.startsWith('copyright:')) {
-        const value = token.slice('copyright:'.length).trim();
-        if (value.length > 0) {
-          filters.push({ field: 'copyright', value: value.toLowerCase() });
-        }
-        continue;
-      }
       remainingTokens.push(token);
     }
 
@@ -161,7 +153,7 @@ export class SearchService {
 
     const metadata = this.getCachedMetadata(file);
     return filters.every((filter) => {
-      const source = filter.field === 'author' ? metadata.author : metadata.copyright;
+      const source = metadata.author;
       if (!source) {
         return false;
       }
@@ -180,8 +172,7 @@ export class SearchService {
 
     const metadata = this.tagService.readMetadata(file.absolutePath);
     const normalized: CachedMetadata = {
-      author: metadata.author?.trim() || undefined,
+      author: metadata.author?.trim() || undefined
-      copyright: metadata.copyright?.trim() || undefined
     };
     this.metadataCache.set(file.id, normalized);
     return normalized;

src/main/services/TagService.ts

@@ -10,15 +10,25 @@ export class TagService {
   public constructor(private readonly database: DatabaseService) {}
 
   /**
-   * Applies tags and categories to a file record and embeds the metadata into the WAV container.
+   * Applies category updates (and optional tag overrides) then embeds metadata into the WAV container.
+   * Preserves existing author, title, and rating fields.
    */
-  public applyTagging(fileId: number, tags: string[], categories: string[]): AudioFileSummary {
+  public applyTagging(fileId: number, tags: string[] | undefined, categories: string[]): AudioFileSummary {
-    const normalisedTags = this.normaliseValues(tags);
     const normalisedCategories = this.normaliseValues(categories);
+    const normalisedTags = Array.isArray(tags) ? this.normaliseValues(tags) : undefined;
     const updated = this.database.updateTagging(fileId, normalisedTags, normalisedCategories);
+    
+    // Read existing metadata to preserve author, title, and rating
+    const existing = this.readMetadata(updated.absolutePath);
+    
     this.writeWaveMetadata(updated.absolutePath, {
-      tags: normalisedTags,
+  tags: normalisedTags ?? updated.tags,
-      categories: normalisedCategories
+  categories: normalisedCategories,
+      title: existing.title,
+      author: existing.author,
+      rating: existing.rating,
+      copyright: existing.copyright,
+      parentId: existing.parentId ?? updated.parentFileId ?? null
     });
     return updated;
   }
@@ -42,25 +52,58 @@ export class TagService {
    */
   public readMetadata(filePath: string): {
     author?: string;
-    copyright?: string;
     title?: string;
     rating?: number;
+    copyright?: string;
+    parentId?: number;
   } {
     try {
       const buffer = fs.readFileSync(filePath);
       const wave = new WaveFile(buffer);
       const tags = this.extractInfoTagMap(wave);
+      
+      // Read from individual fields
+      const title = tags.INAM?.trim() || undefined;
+      const author = tags.IART?.trim() || undefined;
+      const copyright = tags.ICOP?.trim() || undefined;
+      
       const ratingValue = tags.IRTD ? Number.parseInt(tags.IRTD, 10) : undefined;
       let rating: number | undefined;
       if (typeof ratingValue === 'number' && Number.isFinite(ratingValue)) {
         rating = Math.floor(ratingValue / 2);
       }
       
+      // Try to read parentId from JSON comment
+      let parentId: number | undefined;
+      const comment = tags.ICMT?.trim();
+      if (comment) {
+        try {
+          const parsed = JSON.parse(comment);
+          if (parsed && typeof parsed.parentId === 'number') {
+            parentId = parsed.parentId;
+          }
+        } catch {
+          // Not JSON, ignore
+        }
+      }
+      
+      // Fallback to IPAR field if no JSON parentId
+      if (parentId === undefined) {
+        const parentRaw = tags.IPAR?.trim();
+        if (parentRaw && parentRaw.length > 0) {
+          const parsedNum = Number.parseInt(parentRaw, 10);
+          if (Number.isFinite(parsedNum)) {
+            parentId = parsedNum;
+          }
+        }
+      }
+
       return {
-        author: tags.IART?.trim() || undefined,
+        author,
-        copyright: tags.ICOP?.trim() || undefined,
+        title,
-        title: tags.INAM?.trim() || undefined,
+        rating,
-        rating
+        copyright,
+        parentId
       };
     } catch (error) {
       // eslint-disable-next-line no-console -- Logging to devtools console is helpful for diagnosis.
@@ -71,6 +114,7 @@ export class TagService {
 
   /**
    * Writes tags and categories to an organized file as embedded metadata.
+   * All metadata fields are required to prevent accidental clearing.
    */
   public writeMetadataOnly(
     filePath: string,
@@ -79,8 +123,9 @@ export class TagService {
       categories: string[];
       title?: string | null;
       author?: string | null;
-  copyright?: string | null;
       rating?: number;
+      copyright?: string | null;
+      parentId?: number | null;
     }
   ): void {
     this.writeWaveMetadata(filePath, metadata);
@@ -88,6 +133,7 @@ export class TagService {
 
   /**
    * Writes a simple INFO chunk with the provided metadata. Failures are swallowed so DB state remains authoritative.
+   * All metadata fields must be explicitly provided to prevent accidental data loss.
    */
   private writeWaveMetadata(
     filePath: string,
@@ -96,8 +142,9 @@ export class TagService {
       categories: string[];
       title?: string | null;
       author?: string | null;
-  copyright?: string | null;
       rating?: number;
+      copyright?: string | null;
+      parentId?: number | null;
     }
   ): void {
     try {
@@ -108,23 +155,41 @@ export class TagService {
         listInfoTags?: Record<string, string>;
       };
 
-      const tagValuesList = metadata.tags.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+      const tagValuesList = (metadata.tags ?? [])
-      const categoryValuesList = metadata.categories.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+      const categoryValuesList = (metadata.categories ?? [])
+        .map((entry) => entry.trim())
+        .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 trimmedTitle = metadata.title?.toString().trim();
+      const effectiveTitle = trimmedTitle && trimmedTitle.length > 0 ? trimmedTitle : null;
+      const trimmedAuthor = metadata.author?.toString().trim();
+      const effectiveAuthor = trimmedAuthor && trimmedAuthor.length > 0 ? trimmedAuthor : null;
+      const trimmedCopyright = metadata.copyright?.toString().trim();
+      const effectiveCopyright = trimmedCopyright && trimmedCopyright.length > 0 ? trimmedCopyright : null;
+      const parentText = metadata.parentId !== undefined && metadata.parentId !== null
+        ? String(metadata.parentId)
+        : null;
+      const commentPayload = {
+        parentId: metadata.parentId ?? null
+      } satisfies Record<string, unknown>;
+      const commentText = JSON.stringify(commentPayload);
 
       const tagValues: Record<string, string | null> = {
         IKEY: tagText,
-        ICMT: tagText,
+  ICMT: commentText,
         ISBJ: categoryText,
         ISUB: primaryCategory,
         IGNR: null,
-        INAM: metadata.title?.trim()?.length ? metadata.title.trim() : null,
+        INAM: effectiveTitle,
-        IART: metadata.author?.trim()?.length ? metadata.author.trim() : null,
+        IART: effectiveAuthor,
-        ICOP: metadata.copyright?.trim()?.length ? metadata.copyright.trim() : null,
         IRTD: metadata.rating && metadata.rating > 0 ? String(metadata.rating * 2) : null,
+        ICOP: effectiveCopyright,
+        IPAR: parentText,
         ISFT: 'AudioSort'
       };
 
@@ -134,12 +199,13 @@ export class TagService {
       fs.writeFileSync(filePath, updatedBuffer);
 
       console.log(`Wrote metadata to ${filePath}:`, {
-        tags: metadata.tags.join(', '),
+        comment: commentText,
         categories: metadata.categories.join(', '),
-        title: metadata.title,
+        title: effectiveTitle,
-        author: metadata.author,
+        author: effectiveAuthor,
-        copyright: metadata.copyright,
+        copyright: effectiveCopyright,
-        rating: metadata.rating
+        rating: metadata.rating,
+        parentId: metadata.parentId ?? null
       });
     } catch (error) {
       // eslint-disable-next-line no-console -- Logging to devtools console is helpful for diagnosis.

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

@@ -6,6 +6,7 @@ import type {
   AudioFileSummary,
   CategoryRecord,
   LibraryScanSummary,
+  SplitSegmentRequest,
   TagUpdatePayload
 } from '../shared/models';
 
@@ -28,6 +29,10 @@ const api: RendererApi = {
   async listAudioFiles(): Promise<AudioFileSummary[]> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryList);
   },
+  /** 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);
   },
@@ -37,7 +42,10 @@ const api: RendererApi = {
   async moveFile(fileId: number, targetRelativeDirectory: string): Promise<AudioFileSummary> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryMove, fileId, targetRelativeDirectory);
   },
-  async organizeFile(fileId: number, metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }): Promise<AudioFileSummary> {
+  async organizeFile(
+    fileId: number,
+    metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }
+  ): Promise<AudioFileSummary> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryOrganize, fileId, metadata);
   },
   async updateCustomName(fileId: number, customName: string | null): Promise<AudioFileSummary> {
@@ -49,6 +57,9 @@ const api: RendererApi = {
   async deleteFiles(fileIds: number[]): Promise<void> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryDelete, fileIds);
   },
+  async splitFile(fileId: number, segments: SplitSegmentRequest[]): Promise<AudioFileSummary[]> {
+    return ipcRenderer.invoke(IPC_CHANNELS.librarySplit, fileId, segments);
+  },
   async getAudioBuffer(fileId: number): Promise<AudioBufferPayload> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryBuffer, fileId);
   },
@@ -70,7 +81,10 @@ const api: RendererApi = {
   async listMetadataSuggestions(): Promise<{ authors: string[]; copyrights: string[] }> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryMetadataSuggestions);
   },
-  async updateFileMetadata(fileId: number, metadata: { author?: string | null; copyright?: string | null; rating?: number }): Promise<void> {
+  async updateFileMetadata(
+    fileId: number,
+    metadata: { author?: string | null; copyright?: string | null; rating?: number }
+  ): Promise<void> {
     return ipcRenderer.invoke(IPC_CHANNELS.libraryUpdateMetadata, fileId, metadata);
   },
   onMenuAction(channel: string, callback: () => void): () => void {

src/renderer/src/App.tsx

@@ -6,11 +6,14 @@ import CategorySidebar from './components/CategorySidebar';
 import AudioPlayer from './components/AudioPlayer';
 import SettingsDialog from './components/SettingsDialog';
 import DuplicateComparisonDialog from './components/DuplicateComparisonDialog';
+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';
 
+type RightPanelTab = 'listen' | 'edit';
+
 /**
  * Root renderer component orchestrating layout and interactions.
  */
@@ -21,6 +24,7 @@ function App(): JSX.Element {
   const [duplicateGroups, setDuplicateGroups] = useState<{ checksum: string; files: AudioFileSummary[] }[] | null>(null);
   const [showStatusMessage, setShowStatusMessage] = useState(false);
   const [statusFadingOut, setStatusFadingOut] = useState(false);
+  const [activeTab, setActiveTab] = useState<RightPanelTab>('listen');
   
   const statusMessage = useMemo(() => {
     if (!library.lastScan) {
@@ -65,6 +69,47 @@ function App(): JSX.Element {
     [library.files, library.selectedFileId]
   );
 
+  const parentFileFromStore = useMemo(() => {
+    const parentId = selectedFile?.parentFileId ?? null;
+    if (parentId === null) {
+      return null;
+    }
+    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]
@@ -132,10 +177,6 @@ function App(): JSX.Element {
     libraryStore.selectFile(fileId, options);
   };
 
-  const handleSelectAllFiles = () => {
-    libraryStore.selectAllVisibleFiles();
-  };
-
   const handlePlayFile = (file: AudioFileSummary) => {
     loadPlayerFile(file, true);
   };
@@ -158,11 +199,19 @@ function App(): JSX.Element {
     await libraryStore.moveFile(selectedFile.id, targetDirectory);
   };
 
-  const handleOrganize = async (metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }) => {
+  const handleOrganize = async (metadata: { customName?: string; author?: string; copyright?: string; rating?: number }) => {
     if (!selectedFile) {
       return;
     }
     await libraryStore.organizeFile(selectedFile.id, metadata);
+    
+    // Scroll the file into view after organizing (filename may have changed)
+    setTimeout(() => {
+      const element = document.querySelector(`[data-file-id="${selectedFile.id}"]`);
+      if (element) {
+        element.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+      }
+    }, 100);
   };
 
   const handleUpdateCustomName = async (customName: string | null) => {
@@ -172,26 +221,31 @@ function App(): JSX.Element {
     await libraryStore.updateCustomName(selectedFile.id, customName);
   };
 
-  const handleTagUpdate = async (data: { tags: string[]; categories: string[] }) => {
+  const handleTagUpdate = async (categories: string[]) => {
     if (!selectedFile) {
       return;
     }
-    await libraryStore.updateTagging({ fileId: selectedFile.id, ...data });
+    await libraryStore.updateTagging({ fileId: selectedFile.id, categories });
   };
 
-  const handleMultiFileTagUpdate = async (fileId: number, data: { tags: string[]; categories: string[] }) => {
+  const handleOpenParent = (parentId: number) => {
-    await libraryStore.updateTagging({ fileId, ...data });
+    void libraryStore.focusOnFile(parentId);
+    setActiveTab('listen');
+  };
+
+  const handleMultiFileTagUpdate = async (fileId: number, categories: string[]) => {
+    await libraryStore.updateTagging({ fileId, categories });
   };
 
   const handleMultiFileCustomName = async (fileId: number, customName: string | null) => {
     await libraryStore.updateCustomName(fileId, customName);
   };
 
-  const handleMultiFileOrganize = async (fileId: number, metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }) => {
+  const handleMultiFileOrganize = async (fileId: number, metadata: { customName?: string; author?: string; copyright?: string; rating?: number }) => {
     await libraryStore.organizeFile(fileId, metadata);
   };
 
-  const handleMultiFileUpdateMetadata = async (fileId: number, metadata: { author?: string | null; copyright?: string | null; rating?: number }) => {
+  const handleMultiFileUpdateMetadata = async (fileId: number, metadata: { author?: string; copyright?: string; rating?: number }) => {
     await libraryStore.updateFileMetadata(fileId, metadata);
   };
 
@@ -206,7 +260,6 @@ function App(): JSX.Element {
       const newCategories = [...existingCategories, categoryId];
       await libraryStore.updateTagging({
         fileId,
-        tags: file.tags, 
         categories: newCategories
       });
     }
@@ -217,6 +270,18 @@ function App(): JSX.Element {
     setSettingsOpen(false);
   };
 
+  const handleEditModeClose = () => {
+    setActiveTab('listen');
+  };
+
+  const handleEditModeSplitComplete = async (created: AudioFileSummary[]) => {
+    await libraryStore.rescan();
+    setActiveTab('listen');
+    if (created.length > 0) {
+      libraryStore.selectFile(created[0].id);
+    }
+  };
+
   return (
     <div className="app-root">
       {showStatusMessage && statusMessage && (
@@ -240,7 +305,6 @@ function App(): JSX.Element {
           onPlay={handlePlayFile}
           searchValue={library.searchQuery}
           onSearchChange={handleSearch}
-          onSelectAll={handleSelectAllFiles}
         />
         <div className="app-details">
           {isMultiSelect ? (
@@ -254,19 +318,49 @@ function App(): JSX.Element {
               metadataSuggestionsVersion={library.metadataSuggestionsVersion}
             />
           ) : (
+            <>
+              <div className="detail-tabs">
+                <button
+                  type="button"
+                  className={activeTab === 'listen' ? 'detail-tab detail-tab--active' : 'detail-tab'}
+                  onClick={() => setActiveTab('listen')}
+                >
+                  Listen
+                </button>
+                <button
+                  type="button"
+                  className={activeTab === 'edit' ? 'detail-tab detail-tab--active' : 'detail-tab'}
+                  onClick={() => setActiveTab('edit')}
+                  disabled={!selectedFile}
+                >
+                  Edit
+                </button>
+              </div>
+              {activeTab === 'listen' ? (
                 <>
                   <FileDetailPanel
                     file={selectedFile}
+                    parentFile={resolvedParentFile}
                     categories={library.categories}
                     onRename={handleRename}
                     onMove={handleMove}
                     onOrganize={handleOrganize}
                     onUpdateTags={handleTagUpdate}
                     onUpdateCustomName={handleUpdateCustomName}
+                    onOpenParent={handleOpenParent}
                     metadataSuggestionsVersion={library.metadataSuggestionsVersion}
                   />
                   <AudioPlayer snapshot={player} />
                 </>
+              ) : selectedFile ? (
+                <EditModePanel
+                  file={selectedFile}
+                  categories={library.categories}
+                  onClose={handleEditModeClose}
+                  onSplitComplete={handleEditModeSplitComplete}
+                />
+              ) : null}
+            </>
           )}
         </div>
       </main>

src/renderer/src/components/FileDetailPanel.tsx

@@ -2,25 +2,36 @@ import { useCallback, useEffect, useMemo, useRef, useState, type ChangeEvent, ty
 import type { AudioFileSummary, CategoryRecord } from '../../../shared/models';
 import { TagEditor } from './TagEditor';
 
+/**
+ * Normalizes path separators to backslashes for consistent display on Windows.
+ */
+function normalizePathDisplay(path: string): string {
+  return path.replace(/\//g, '\\');
+}
+
 /**
  * Props for FileDetailPanel component.
  */
 export interface FileDetailPanelProps {
   file: AudioFileSummary | null;
+  /** Optional summary of the parent file when this entry was generated from another file. */
+  parentFile: AudioFileSummary | null;
   categories: CategoryRecord[];
   onRename(newName: string): Promise<void>;
   onMove(targetRelativeDirectory: string): Promise<void>;
   /** Organizes a file with optional metadata fields (customName, author, copyright, rating 1-5). */
-  onOrganize(metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }): Promise<void>;
+  onOrganize(metadata: { customName?: string; author?: string; copyright?: string; rating?: number }): Promise<void>;
-  onUpdateTags(data: { tags: string[]; categories: string[] }): Promise<void>;
+  onUpdateTags(categories: string[]): Promise<void>;
   onUpdateCustomName(customName: string | null): Promise<void>;
+  /** Invoked when the user requests to open the parent file. */
+  onOpenParent?(parentId: number): void;
   metadataSuggestionsVersion: number;
 }
 
 /**
  * Displays metadata for the selected file with rename, move, and tagging controls.
  */
-export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize, onUpdateTags, onUpdateCustomName, metadataSuggestionsVersion }: FileDetailPanelProps): JSX.Element {
+export function FileDetailPanel({ file, parentFile, categories, onRename, onMove, onOrganize, onUpdateTags, onUpdateCustomName, onOpenParent, metadataSuggestionsVersion }: FileDetailPanelProps): JSX.Element {
   const [isEditingCustomName, setIsEditingCustomName] = useState(false);
   const [moveDraft, setMoveDraft] = useState('');
   const [customNameDraft, setCustomNameDraft] = useState('');
@@ -192,7 +203,7 @@ export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize
     }
   };
 
-  const triggerOrganize = async (overrides?: { author?: string | null; rating?: number; customName?: string | null }) => {
+  const triggerOrganize = async (overrides?: { author?: string; rating?: number; customName?: string | null }, force = false) => {
     if (!file) {
       return;
     }
@@ -202,7 +213,7 @@ export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize
     const nextCustomNameRaw =
       overrides?.customName !== undefined ? overrides.customName ?? '' : customNameDraft;
 
-  const trimmedAuthor = (nextAuthorRaw ?? '').trim();
+    const trimmedAuthor = nextAuthorRaw.trim();
     const trimmedCustomName = (nextCustomNameRaw ?? '').toString().trim();
     const comparisonState = {
       author: trimmedAuthor,
@@ -213,6 +224,7 @@ export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize
 
     const previous = initialMetadataRef.current;
     if (
+      !force &&
       previous &&
       previous.author === comparisonState.author &&
       previous.copyright === comparisonState.copyright &&
@@ -224,18 +236,17 @@ export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize
 
     setBusy(true);
     try {
-      const authorPayload = trimmedAuthor.length > 0 ? trimmedAuthor : null;
       if (file.categories.length === 0) {
         // No categories - just save metadata without organizing
         await window.api.updateFileMetadata(file.id, {
-          author: authorPayload,
+          author: trimmedAuthor.length > 0 ? trimmedAuthor : undefined,
           rating: comparisonState.rating > 0 ? comparisonState.rating : undefined
         });
       } else {
         // Has categories - organize the file
         await onOrganize({
-          customName: trimmedCustomName.length > 0 ? trimmedCustomName : null,
+          customName: trimmedCustomName.length > 0 ? trimmedCustomName : undefined,
-          author: authorPayload,
+          author: trimmedAuthor.length > 0 ? trimmedAuthor : undefined,
           rating: comparisonState.rating > 0 ? comparisonState.rating : undefined
         });
       }
@@ -251,10 +262,12 @@ export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize
     }
   };
 
-  const handleTagSave = async (data: { tags: string[]; categories: string[] }) => {
+  const handleCategorySave = async (selectedCategories: string[]) => {
     setBusy(true);
     try {
-      await onUpdateTags(data);
+      await onUpdateTags(selectedCategories);
+    } catch (error) {
+      console.error('Failed to update categories', error);
     } finally {
       setBusy(false);
     }
@@ -269,6 +282,13 @@ export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize
     }
   };
 
+  const handleOpenParent = () => {
+    if (!file || file.parentFileId === null || !onOpenParent) {
+      return;
+    }
+    onOpenParent(file.parentFileId);
+  };
+
   const toggleTagSection = () => {
     setIsTagSectionExpanded((value) => !value);
   };
@@ -293,15 +313,65 @@ export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize
               {file.customName || file.displayName}
             </h1>
           )}
+          <div 
+            style={{ display: 'flex', alignItems: 'center', gap: '8px' }}
+            onMouseEnter={(e) => {
+              const btn = e.currentTarget.querySelector('.file-regenerate-name') as HTMLElement;
+              if (btn) btn.style.opacity = '1';
+            }}
+            onMouseLeave={(e) => {
+              const btn = e.currentTarget.querySelector('.file-regenerate-name') as HTMLElement;
+              if (btn) btn.style.opacity = '0';
+            }}
+          >
             <p 
               onClick={handleOpenFolder}
-            style={{ cursor: 'pointer', opacity: 0.7, transition: 'opacity 0.2s ease' }}
+              style={{ cursor: 'pointer', opacity: 0.7, transition: 'opacity 0.2s ease', margin: 0 }}
               onMouseEnter={(e) => e.currentTarget.style.opacity = '1'}
               onMouseLeave={(e) => e.currentTarget.style.opacity = '0.7'}
               title="Click to open in folder"
             >
-            {file.relativePath}
+              {normalizePathDisplay(file.relativePath)}
             </p>
+            <button
+              type="button"
+              className="file-regenerate-name"
+              onClick={async (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                setBusy(true);
+                try {
+                  await triggerOrganize({}, true);
+                } finally {
+                  setBusy(false);
+                }
+              }}
+              disabled={busy}
+              title="Regenerate filename based on current metadata"
+              style={{ 
+                padding: '4px 8px',
+                fontSize: '18px',
+                opacity: 0,
+                transition: 'opacity 0.2s ease',
+                background: 'none',
+                border: 'none',
+                cursor: 'pointer',
+                color: 'inherit'
+              }}
+            >
+              ↻
+            </button>
+          </div>
+          {file.parentFileId !== null && onOpenParent ? (
+            <button
+              type="button"
+              className="file-parent-link"
+              onClick={handleOpenParent}
+              title={parentFile ? `Open source file ${parentFile.displayName}` : 'Open source file'}
+            >
+              🔗 {parentFile ? parentFile.customName || parentFile.displayName : `Source missing (#${file.parentFileId})`}
+            </button>
+          ) : null}
         </div>
         <div className="file-meta-grid">
           <div>{formatBytes(file.size)}</div>
@@ -375,17 +445,16 @@ export function FileDetailPanel({ file, categories, onRename, onMove, onOrganize
           onClick={toggleTagSection}
           aria-expanded={isTagSectionExpanded}
         >
-          <span className="tag-editor-toggle-label">Tags</span>
+          <span className="tag-editor-toggle-label">Categories</span>
           <span className="tag-editor-toggle-icon" aria-hidden="true">
             {isTagSectionExpanded ? 'v' : '>'}
           </span>
         </button>
         <div className={isTagSectionExpanded ? 'tag-editor-content tag-editor-content--open' : 'tag-editor-content'} aria-hidden={!isTagSectionExpanded}>
           <TagEditor
-            tags={file.tags}
             categories={file.categories}
             availableCategories={categories}
-            onSave={handleTagSave}
+            onSave={handleCategorySave}
             showHeading={false}
           />
         </div>

src/renderer/src/components/FileList.tsx

@@ -9,26 +9,21 @@ export interface FileListProps {
   onPlay?(file: AudioFileSummary): void;
   searchValue: string;
   onSearchChange(value: string): void;
-  /**
-   * Invoked when the user requests to select every visible file (Ctrl+A).
-   */
-  onSelectAll?(): void;
 }
 
 /**
  * Vertical list of WAV files with highlighting for the active selection.
  */
-export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, searchValue, onSearchChange, onSelectAll }: FileListProps): JSX.Element {
+export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, searchValue, onSearchChange }: FileListProps): JSX.Element {
   const buttonRefs = useRef(new Map<number, HTMLButtonElement>());
   const waveformCacheRef = useRef<Record<number, WaveformVisual>>({});
   const [, forceWaveformUpdate] = useReducer((value: number) => value + 1, 0);
   const dragGhostRef = useRef<HTMLElement | null>(null);
-  const dragRotation = useRef(0);
+  const dragRotation = useRef<number>(0);
-  const lastDragX = useRef(0);
+  const lastDragX = useRef<number>(0);
   const dropTargetPosition = useRef<{ x: number; y: number } | null>(null);
-  const dragOffset = useRef({ x: 0, y: 0 });
+  const dragOffset = useRef<{ x: number; y: number }>({ x: 0, y: 0 });
-  const dragStartTime = useRef(0);
+  const dragStartTime = useRef<number>(0);
-  const listContainerRef = useRef<HTMLDivElement | null>(null);
 
   useEffect(() => {
     if (selectedId === null) {
@@ -44,6 +39,7 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
     if (isTypingContext || isEditable) {
       return;
     }
+    // Keep keyboard focus aligned with the active selection.
     button.focus();
   }, [selectedId]);
 
@@ -92,43 +88,6 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
     };
   }, [files]);
 
-  useEffect(() => {
-    if (!onSelectAll) {
-      return undefined;
-    }
-
-    const handleKeyDown = (event: KeyboardEvent) => {
-      if (!(event.ctrlKey || event.metaKey)) {
-        return;
-      }
-      if (event.key !== 'a' && event.key !== 'A') {
-        return;
-      }
-
-      const activeElement = document.activeElement as HTMLElement | null;
-      if (!activeElement) {
-        return;
-      }
-      const isTypingContext = activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement;
-      const isEditable = activeElement.getAttribute('contenteditable') === 'true';
-      if (isTypingContext || isEditable) {
-        return;
-      }
-
-      if (listContainerRef.current && !listContainerRef.current.contains(activeElement)) {
-        return;
-      }
-
-      event.preventDefault();
-      onSelectAll();
-    };
-
-    window.addEventListener('keydown', handleKeyDown);
-    return () => {
-      window.removeEventListener('keydown', handleKeyDown);
-    };
-  }, [onSelectAll]);
-
   const handleClick = (fileId: number, event: React.MouseEvent) => {
     onSelect(fileId, {
       multi: event.ctrlKey || event.metaKey,
@@ -166,7 +125,7 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
           placeholder="Search files..."
         />
       </div>
-  <div className="file-list-items" ref={listContainerRef}>
+      <div className="file-list-items">
       {files.map((file) => {
         const isActive = file.id === selectedId;
         const isSelected = selectedIds.has(file.id);
@@ -186,6 +145,7 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
             type="button"
             className={className}
             draggable={true}
+            data-file-id={file.id}
             ref={(node) => {
               if (node) {
                 buttonRefs.current.set(file.id, node);
@@ -196,6 +156,8 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
             onClick={(event) => handleClick(file.id, event)}
             onDoubleClick={() => handleDoubleClick(file)}
             onDragStart={(event) => {
+              // If dragging an unselected item, only drag that item
+              // If dragging a selected item, drag all selected items
               const draggedIds = selectedIds.has(file.id) ? Array.from(selectedIds) : [file.id];
               
               event.dataTransfer.setData('application/audiosort-file', JSON.stringify({
@@ -204,6 +166,7 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
               }));
               event.dataTransfer.effectAllowed = 'copy';
               
+              // Create transparent drag image to hide the default
               const transparent = document.createElement('div');
               transparent.style.width = '1px';
               transparent.style.height = '1px';
@@ -212,6 +175,7 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
               event.dataTransfer.setDragImage(transparent, 0, 0);
               setTimeout(() => transparent.remove(), 0);
               
+              // Calculate offset from click position to element center
               const sourceElement = event.currentTarget as HTMLElement;
               const rect = sourceElement.getBoundingClientRect();
               const elementCenterX = rect.left + rect.width / 2;
@@ -221,18 +185,21 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
                 y: elementCenterY - event.clientY
               };
               
+              // Calculate transition duration based on offset distance
               const offsetDistance = Math.sqrt(
                 dragOffset.current.x * dragOffset.current.x + 
                 dragOffset.current.y * dragOffset.current.y
               );
               const maxDistance = Math.sqrt(rect.width * rect.width + rect.height * rect.height) / 2;
               const normalizedDistance = Math.min(offsetDistance / maxDistance, 1);
-              const transitionDuration = 0.1 + normalizedDistance * 0.2;
+              const transitionDuration = 0.1 + normalizedDistance * 0.2; // 0.1s to 0.3s
               
               dragStartTime.current = Date.now();
               
+              // Clone the current element for custom floating preview
               const ghost = sourceElement.cloneNode(true) as HTMLElement;
               
+              // Create a wrapper for rotation that doesn't affect position transition
               const rotationWrapper = document.createElement('div');
               rotationWrapper.style.position = 'fixed';
               rotationWrapper.style.top = `${event.clientY}px`;
@@ -256,6 +223,7 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
               rotationWrapper.appendChild(ghost);
               document.body.appendChild(rotationWrapper);
               
+              // Trigger the offset transition to center
               requestAnimationFrame(() => {
                 if (ghost.parentNode) {
                   ghost.style.transform = `translate(-50%, -50%)`;
@@ -277,19 +245,25 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
               const clamped = Math.max(-12, Math.min(12, blended));
               dragRotation.current = clamped;
               
+              // Update wrapper position (no rotation here)
               dragGhostRef.current.style.top = `${event.clientY}px`;
               dragGhostRef.current.style.left = `${event.clientX}px`;
+              
+              // Apply rotation directly to wrapper without transition
               dragGhostRef.current.style.transform = `rotate(${clamped}deg)`;
               
+              // Track position for potential drop animation
               dropTargetPosition.current = { x: event.clientX, y: event.clientY };
             }}
             onDragEnd={(event) => {
               const wrapper = dragGhostRef.current;
               if (!wrapper) return;
               
+              // Check if this was a successful drop (dropEffect will be 'copy' if accepted)
               const wasDropped = event.dataTransfer.dropEffect === 'copy';
               
               if (wasDropped && dropTargetPosition.current) {
+                // Animate shrink into drop position
                 wrapper.style.transition = 'all 0.3s cubic-bezier(0.34, 1.56, 0.64, 1)';
                 wrapper.style.transform = `rotate(0deg) scale(0)`;
                 wrapper.style.opacity = '0';
@@ -299,6 +273,7 @@ export function FileList({ files, selectedId, selectedIds, onSelect, onPlay, sea
                   dragGhostRef.current = null;
                 }, 300);
               } else {
+                // No drop or cancelled - remove immediately
                 wrapper.remove();
                 dragGhostRef.current = null;
               }

src/renderer/src/components/MultiFileEditor.tsx

@@ -6,38 +6,23 @@ import { TagEditor } from './TagEditor';
 export interface MultiFileEditorProps {
   files: AudioFileSummary[];
   categories: CategoryRecord[];
-  onUpdateTags(fileId: number, data: { tags: string[]; categories: string[] }): Promise<void>;
+  onUpdateTags(fileId: number, categories: string[]): Promise<void>;
   onUpdateCustomName(fileId: number, customName: string | null): Promise<void>;
-  onOrganize(fileId: number, metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }): Promise<void>;
+  onOrganize(fileId: number, metadata: { customName?: string | null; author?: string | null; rating?: number }): Promise<void>;
-  onUpdateMetadata(fileId: number, metadata: { author?: string | null; copyright?: string | null; rating?: number }): Promise<void>;
+  onUpdateMetadata(fileId: number, metadata: { author?: string | null; rating?: number }): Promise<void>;
   metadataSuggestionsVersion: number;
 }
 
 /**
- * Multi-file tag editor that shows aggregated metadata and allows batch editing.
+ * Multi-file metadata editor that focuses on shared categories and attributes.
  */
 export function MultiFileEditor({ files, categories, onUpdateTags, onUpdateCustomName, onOrganize, onUpdateMetadata, metadataSuggestionsVersion }: MultiFileEditorProps): JSX.Element {
   const [sharedCustomName, setSharedCustomName] = useState('');
   const [sharedAuthor, setSharedAuthor] = useState('');
-  const [sharedCopyright, setSharedCopyright] = useState('');
   const [sharedRating, setSharedRating] = useState(0);
-  const [suggestions, setSuggestions] = useState<{ authors: string[]; copyrights: string[] }>({ authors: [], copyrights: [] });
+  const [suggestions, setSuggestions] = useState<{ authors: string[] }>({ authors: [] });
   const [isTagSectionExpanded, setIsTagSectionExpanded] = useState(true);
 
-  // Compute aggregated tags and categories for TagEditor
-  const aggregatedTags = useMemo(() => {
-    const tagCounts = new Map<string, number>();
-    for (const file of files) {
-      for (const tag of file.tags) {
-        tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
-      }
-    }
-    // Only show tags that appear in all files
-    return Array.from(tagCounts.entries())
-      .filter(([, count]) => count === files.length)
-      .map(([tag]) => tag);
-  }, [files]);
-
   const aggregatedCategories = useMemo(() => {
     const categoryCounts = new Map<string, number>();
     for (const file of files) {
@@ -53,7 +38,7 @@ export function MultiFileEditor({ files, categories, onUpdateTags, onUpdateCusto
 
   const listRef = useRef<HTMLDivElement>(null);
 
-  type SuggestionKey = 'authors' | 'copyrights';
+  type SuggestionKey = 'authors';
 
   const appendSuggestion = useCallback((value: string, key: SuggestionKey) => {
     const trimmed = value.trim();
@@ -84,21 +69,9 @@ export function MultiFileEditor({ files, categories, onUpdateTags, onUpdateCusto
     return base.filter((entry) => entry.toLowerCase().includes(query)).slice(0, 5);
   }, [sharedAuthor, suggestions.authors]);
 
-  const filteredCopyrightSuggestions = useMemo(() => {
-    if (suggestions.copyrights.length === 0) {
-      return [] as string[];
-    }
-    const query = sharedCopyright.trim().toLowerCase();
-    const base = suggestions.copyrights.filter((entry) => entry.toLowerCase() !== query);
-    if (query.length === 0) {
-      return base.slice(0, 5);
-    }
-    return base.filter((entry) => entry.toLowerCase().includes(query)).slice(0, 5);
-  }, [sharedCopyright, suggestions.copyrights]);
-
   useEffect(() => {
     let cancelled = false;
-    setSuggestions({ authors: [], copyrights: [] });
+    setSuggestions({ authors: [] });
     void (async () => {
       try {
         const result = await window.api.listMetadataSuggestions();
@@ -106,8 +79,7 @@ export function MultiFileEditor({ files, categories, onUpdateTags, onUpdateCusto
           return;
         }
         setSuggestions({
-          authors: result.authors,
+          authors: result.authors
-          copyrights: result.copyrights
         });
       } catch (error) {
         if (!cancelled) {
@@ -188,37 +160,6 @@ export function MultiFileEditor({ files, categories, onUpdateTags, onUpdateCusto
     }
   };
 
-  const handleSharedCopyrightBlur = async () => {
-    const normalized = sharedCopyright.trim();
-    
-    if (normalized.length === 0) return;
-    
-    try {
-      let failureCount = 0;
-      for (const file of files) {
-        try {
-          if (file.categories.length > 0) {
-            await onOrganize(file.id, { copyright: normalized });
-          } else {
-            await onUpdateMetadata(file.id, { copyright: normalized });
-          }
-        } catch (error) {
-          failureCount += 1;
-          console.error(`Failed to update copyright for file ${file.id} (${file.fileName}):`, error);
-        }
-      }
-      if (failureCount > 0) {
-        console.error(`${failureCount} file(s) failed to update copyright`);
-      }
-      
-      if (normalized.length > 0) {
-        appendSuggestion(normalized, 'copyrights');
-      }
-    } catch (error) {
-      console.error('Failed to update copyright:', error);
-    }
-  };
-
   const handleSharedRatingChange = async (rating: number) => {
     setSharedRating(rating);
     
@@ -244,22 +185,22 @@ export function MultiFileEditor({ files, categories, onUpdateTags, onUpdateCusto
     }
   };
 
-  const handleTagSave = async (data: { tags: string[]; categories: string[] }) => {
+  const handleCategorySave = async (selectedCategories: string[]) => {
     try {
       let failureCount = 0;
       for (const file of files) {
         try {
-          await onUpdateTags(file.id, data);
+          await onUpdateTags(file.id, selectedCategories);
         } catch (error) {
           failureCount += 1;
-          console.error(`Failed to update tags for file ${file.id} (${file.fileName}):`, error);
+          console.error(`Failed to update categories for file ${file.id} (${file.fileName}):`, error);
         }
       }
       if (failureCount > 0) {
-        console.error(`${failureCount} file(s) failed to update tags`);
+        console.error(`${failureCount} file(s) failed to update categories`);
       }
     } catch (error) {
-      console.error('Failed to update tags:', error);
+      console.error('Failed to update categories:', error);
     }
   };
 
@@ -325,39 +266,6 @@ export function MultiFileEditor({ files, categories, onUpdateTags, onUpdateCusto
                 </div>
               )}
             </label>
-            <label>
-              <span>Copyright</span>
-              <input
-                type="text"
-                value={sharedCopyright}
-                onChange={(e) => setSharedCopyright(e.target.value)}
-                onBlur={handleSharedCopyrightBlur}
-                onKeyDown={(e) => {
-                  if (e.key === 'Enter') {
-                    e.currentTarget.blur();
-                  }
-                }}
-                placeholder="Copyright information"
-              />
-              {filteredCopyrightSuggestions.length > 0 && (
-                <div className="metadata-suggestion-list" role="listbox" aria-label="Copyright suggestions">
-                  {filteredCopyrightSuggestions.map((option) => (
-                    <button
-                      key={option}
-                      type="button"
-                      className="metadata-suggestion"
-                      onMouseDown={(event) => event.preventDefault()}
-                      onClick={() => {
-                        setSharedCopyright(option);
-                        void handleSharedCopyrightBlur();
-                      }}
-                    >
-                      {option}
-                    </button>
-                  ))}
-                </div>
-              )}
-            </label>
             <label>
               <span>Rating</span>
               <div className="star-rating">
@@ -387,17 +295,16 @@ export function MultiFileEditor({ files, categories, onUpdateTags, onUpdateCusto
             onClick={toggleTagSection}
             aria-expanded={isTagSectionExpanded}
           >
-            <span className="tag-editor-toggle-label">Tags</span>
+            <span className="tag-editor-toggle-label">Categories</span>
             <span className="tag-editor-toggle-icon" aria-hidden="true">
               {isTagSectionExpanded ? 'v' : '>'}
             </span>
           </button>
           <div className={isTagSectionExpanded ? 'tag-editor-content tag-editor-content--open' : 'tag-editor-content'} aria-hidden={!isTagSectionExpanded}>
             <TagEditor
-              tags={aggregatedTags}
               categories={aggregatedCategories}
               availableCategories={categories}
-              onSave={handleTagSave}
+              onSave={handleCategorySave}
               showHeading={false}
             />
           </div>

src/renderer/src/components/SearchBar.tsx

@@ -8,11 +8,10 @@ import {
   type SyntheticEvent
 } from 'react';
 
-type SuggestionType = 'author' | 'copyright';
+type SuggestionType = 'author';
 
 interface MetadataSuggestionPayload {
   authors: string[];
-  copyrights: string[];
 }
 
 export interface SearchBarProps {
@@ -30,7 +29,7 @@ export interface SearchBarProps {
 export function SearchBar({ value, onChange, onRescan, onFindDuplicates, onOpenSettings, metadataSuggestionsVersion }: SearchBarProps): JSX.Element {
   const [draft, setDraft] = useState(value);
   const [caretIndex, setCaretIndex] = useState<number | null>(null);
-  const [suggestions, setSuggestions] = useState<MetadataSuggestionPayload>({ authors: [], copyrights: [] });
+  const [suggestions, setSuggestions] = useState<MetadataSuggestionPayload>({ authors: [] });
   const [loadingSuggestions, setLoadingSuggestions] = useState(false);
   const [rescanBusy, setRescanBusy] = useState(false);
   const inputRef = useRef<HTMLInputElement>(null);
@@ -44,8 +43,7 @@ export function SearchBar({ value, onChange, onRescan, onFindDuplicates, onOpenS
     try {
       const result = await window.api.listMetadataSuggestions();
       setSuggestions({
-        authors: result.authors,
+        authors: result.authors
-        copyrights: result.copyrights
       });
     } catch (error) {
       console.error('Failed to load search suggestions', error);
@@ -55,7 +53,7 @@ export function SearchBar({ value, onChange, onRescan, onFindDuplicates, onOpenS
   }, []);
 
   useEffect(() => {
-    setSuggestions({ authors: [], copyrights: [] });
+    setSuggestions({ authors: [] });
     void refreshSuggestions();
   }, [refreshSuggestions, metadataSuggestionsVersion]);
 
@@ -65,7 +63,7 @@ export function SearchBar({ value, onChange, onRescan, onFindDuplicates, onOpenS
   }, [caretIndex, draft]);
 
   const activeToken = useMemo(() => {
-    const match = analysisTarget.match(/(author|copyright):([^\s]*)$/i);
+    const match = analysisTarget.match(/(author):([^\s]*)$/i);
     if (!match) {
       return null;
     }
@@ -80,7 +78,7 @@ export function SearchBar({ value, onChange, onRescan, onFindDuplicates, onOpenS
     if (!activeToken) {
       return [] as string[];
     }
-    const pool = activeToken.type === 'author' ? suggestions.authors : suggestions.copyrights;
+    const pool = suggestions.authors;
     const trimmedTerm = activeToken.term.trim();
     if (trimmedTerm.length === 0) {
       return pool.slice(0, 6);

src/renderer/src/components/TagEditor.tsx

@@ -1,13 +1,4 @@
-import {
+import { useEffect, useMemo, useState, useRef, useLayoutEffect, type UIEvent } from 'react';
-  useEffect,
-  useMemo,
-  useState,
-  useRef,
-  useLayoutEffect,
-  type ChangeEvent,
-  type UIEvent,
-  type CSSProperties
-} from 'react';
 import type { CategoryRecord } from '../../../shared/models';
 import {
   getCollapsedGroups,
@@ -24,19 +15,17 @@ import {
 import type { CategorySwatch } from '../utils/categoryColors';
 
 export interface TagEditorProps {
-  tags: string[];
   categories: string[];
   availableCategories: CategoryRecord[];
-  onSave(data: { tags: string[]; categories: string[] }): void;
+  onSave(categories: string[]): void | Promise<void>;
   /** If false the internal heading is omitted. Defaults to true. */
   showHeading?: boolean;
 }
 
 /**
- * Allows editing free-form tags and selecting UCS categories.
+ * Provides category selection controls without exposing free-form tag editing.
  */
-export function TagEditor({ tags, categories, availableCategories, onSave, showHeading = true }: TagEditorProps): JSX.Element {
+export function TagEditor({ categories, availableCategories, onSave, showHeading = true }: TagEditorProps): JSX.Element {
-  const [tagDraft, setTagDraft] = useState(tags.join(', '));
   const [categoryFilter, setCategoryFilter] = useState('');
   const [selectedCategories, setSelectedCategories] = useState(new Set(categories));
   const [isCategoryListExpanded, setIsCategoryListExpanded] = useState(false);
@@ -52,7 +41,6 @@ export function TagEditor({ tags, categories, availableCategories, onSave, showH
   const isFirstRender = useRef(true);
 
   useEffect(() => {
-    setTagDraft(tags.join(', '));
     setSelectedCategories(new Set(categories));
     
     if (!isFirstRender.current) {
@@ -61,7 +49,7 @@ export function TagEditor({ tags, categories, availableCategories, onSave, showH
     } else {
       isFirstRender.current = false;
     }
-  }, [tags, categories]);
+  }, [categories]);
 
   const { groupedCategories, filteredResults } = useMemo(() => {
     const filter = categoryFilter.trim().toLowerCase();
@@ -83,16 +71,18 @@ export function TagEditor({ tags, categories, availableCategories, onSave, showH
   }, [availableCategories, categoryFilter]);
 
   const selectedCategoryRecords = useMemo(
-    () => availableCategories
+    () => {
-      .filter((entry) => selectedCategories.has(entry.id))
+      // Preserve the order from the categories prop (first category is primary)
-      .sort((left, right) => {
+      const orderedRecords: CategoryRecord[] = [];
-        const topLevelComparison = left.category.localeCompare(right.category);
+      for (const catId of categories) {
-        if (topLevelComparison !== 0) {
+        const record = availableCategories.find((entry) => entry.id === catId);
-          return topLevelComparison;
+        if (record && selectedCategories.has(catId)) {
+          orderedRecords.push(record);
         }
-        return left.subCategory.localeCompare(right.subCategory);
+      }
-      }),
+      return orderedRecords;
-    [availableCategories, selectedCategories]
+    },
+    [availableCategories, selectedCategories, categories]
   );
 
   const categoryColorMap = useMemo(() => {
@@ -146,20 +136,17 @@ export function TagEditor({ tags, categories, availableCategories, onSave, showH
       next.add(categoryId);
     }
     setSelectedCategories(next);
-    
+    onSave(Array.from(next));
-    const parsedTags = tagDraft
-      .split(',')
-      .map((value: string) => value.trim())
-      .filter((value: string) => value.length > 0);
-    onSave({ tags: parsedTags, categories: Array.from(next) });
   };
 
-  const handleTagBlur = () => {
+  const handleSetPrimaryCategory = (categoryId: string) => {
-    const parsedTags = tagDraft
+    const currentList = Array.from(selectedCategories);
-      .split(',')
+    // Remove the category from its current position
-      .map((value: string) => value.trim())
+    const filteredList = currentList.filter((id) => id !== categoryId);
-      .filter((value: string) => value.length > 0);
+    // Add it to the front
-    onSave({ tags: parsedTags, categories: Array.from(selectedCategories) });
+    const reorderedList = [categoryId, ...filteredList];
+    setSelectedCategories(new Set(reorderedList));
+    void onSave(reorderedList);
   };
 
   const handleRemoveCategory = (categoryId: string) => {
@@ -174,11 +161,7 @@ export function TagEditor({ tags, categories, availableCategories, onSave, showH
       return;
     }
     setSelectedCategories(new Set());
-    const parsedTags = tagDraft
+    onSave([]);
-      .split(',')
-      .map((value: string) => value.trim())
-      .filter((value: string) => value.length > 0);
-    onSave({ tags: parsedTags, categories: [] });
   };
 
   const toggleCategoryList = () => {
@@ -187,18 +170,127 @@ export function TagEditor({ tags, categories, availableCategories, onSave, showH
 
   return (
     <section className="tag-editor">
-      {showHeading && <h2>Tags</h2>}
+      {showHeading && <h2>Categories</h2>}
-      <textarea
+      <div className="selected-categories">
-        value={tagDraft}
+        <div className="selected-category-chip-list">
-        onChange={(event: ChangeEvent<HTMLTextAreaElement>) => setTagDraft(event.target.value)}
+          {selectedCategoryRecords.length === 0 && <span className="selected-category-empty">No categories selected</span>}
-        onBlur={handleTagBlur}
+          {selectedCategoryRecords.map((entry, index) => {
-        placeholder="Comma separated tags"
+            const categoryLabel = formatCategoryLabel(entry.category);
-        rows={3}
+            const subCategoryLabel = formatCategoryLabel(entry.subCategory);
-      />
+            const isPrimary = index === 0;
+            return (
+              <div
+                key={entry.id}
+                className="selected-category-chip"
+                style={{ 
+                  ...createCategoryStyleVars(categoryColorMap.get(entry.id)),
+                  display: 'inline-flex',
+                  alignItems: 'center',
+                  gap: '4px',
+                  position: 'relative'
+                }}
+                onMouseEnter={(e) => {
+                  const star = e.currentTarget.querySelector('.category-star-button') as HTMLElement;
+                  if (star && !isPrimary) {
+                    star.style.opacity = '1';
+                    star.style.width = 'auto';
+                    star.style.padding = '0 4px';
+                  }
+                  const removeBtn = e.currentTarget.querySelector('.selected-category-chip-remove-button') as HTMLElement;
+                  if (removeBtn) {
+                    removeBtn.style.opacity = '1';
+                    removeBtn.style.width = 'auto';
+                    removeBtn.style.padding = '0 4px';
+                  }
+                }}
+                onMouseLeave={(e) => {
+                  const star = e.currentTarget.querySelector('.category-star-button') as HTMLElement;
+                  if (star && !isPrimary) {
+                    star.style.opacity = '0';
+                    star.style.width = '0';
+                    star.style.padding = '0';
+                  }
+                  const removeBtn = e.currentTarget.querySelector('.selected-category-chip-remove-button') as HTMLElement;
+                  if (removeBtn) {
+                    removeBtn.style.opacity = '0';
+                    removeBtn.style.width = '0';
+                    removeBtn.style.padding = '0';
+                  }
+                }}
+                title={isPrimary ? `${categoryLabel} ${subCategoryLabel} (Primary - used for organization)` : `${categoryLabel} ${subCategoryLabel}`}
+              >
+                <button
+                  type="button"
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    handleSetPrimaryCategory(entry.id);
+                  }}
+                  className="category-star-button"
+                  style={{
+                    background: 'none',
+                    border: 'none',
+                    padding: isPrimary ? '0 4px' : '0',
+                    margin: 0,
+                    cursor: 'pointer',
+                    fontSize: '14px',
+                    opacity: isPrimary ? 1 : 0,
+                    width: isPrimary ? 'auto' : '0',
+                    overflow: 'hidden',
+                    transition: 'opacity 0.2s ease, width 0.2s ease, padding 0.2s ease',
+                    color: isPrimary ? 'gold' : 'currentColor',
+                    flexShrink: 0
+                  }}
+                  title={isPrimary ? 'Primary category' : 'Set as primary category'}
+                  aria-label={isPrimary ? 'Primary category' : 'Set as primary category'}
+                >
+                  {isPrimary ? '★' : '☆'}
+                </button>
+                <span className="selected-category-chip-label">
+                  <span className="category-label category-label--muted">{categoryLabel}</span>
+                  <span className="category-label category-label--primary">{subCategoryLabel}</span>
+                </span>
+                <button
+                  type="button"
+                  className="selected-category-chip-remove-button"
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    handleRemoveCategory(entry.id);
+                  }}
+                  style={{
+                    background: 'none',
+                    border: 'none',
+                    padding: '0',
+                    margin: 0,
+                    cursor: 'pointer',
+                    fontSize: '18px',
+                    lineHeight: 1,
+                    opacity: 0,
+                    width: '0',
+                    overflow: 'hidden',
+                    transition: 'opacity 0.2s ease, width 0.2s ease, padding 0.2s ease',
+                    flexShrink: 0
+                  }}
+                  aria-label="Remove category"
+                >
+                  <span aria-hidden="true">×</span>
+                </button>
+              </div>
+            );
+          })}
+        </div>
+        <button
+          type="button"
+          className="ghost-button selected-category-clear"
+          onClick={handleClearCategories}
+          disabled={selectedCategories.size === 0}
+        >
+          Clear All
+        </button>
+      </div>
       <div className="category-filter">
         <input
           value={categoryFilter}
-          onChange={(event: ChangeEvent<HTMLInputElement>) => setCategoryFilter(event.target.value)}
+          onChange={(event) => setCategoryFilter(event.target.value)}
           placeholder="Filter UCS categories"
         />
       </div>
@@ -234,39 +326,6 @@ export function TagEditor({ tags, categories, availableCategories, onSave, showH
           <div className="category-filter-empty">No categories match this filter.</div>
         )
       )}
-      <div className="selected-categories">
-        <div className="selected-category-chip-list">
-          {selectedCategoryRecords.length === 0 && <span className="selected-category-empty">No categories selected</span>}
-          {selectedCategoryRecords.map((entry) => {
-            const categoryLabel = formatCategoryLabel(entry.category);
-            const subCategoryLabel = formatCategoryLabel(entry.subCategory);
-            return (
-              <button
-                key={entry.id}
-                type="button"
-                className="selected-category-chip"
-                onClick={() => handleRemoveCategory(entry.id)}
-                style={createCategoryStyleVars(categoryColorMap.get(entry.id))}
-                title={`${categoryLabel} ${subCategoryLabel}`}
-              >
-                <span className="selected-category-chip-label">
-                  <span className="category-label category-label--muted">{categoryLabel}</span>
-                  <span className="category-label category-label--primary">{subCategoryLabel}</span>
-                </span>
-                <span className="selected-category-chip-remove" aria-hidden="true">×</span>
-              </button>
-            );
-          })}
-        </div>
-        <button
-          type="button"
-          className="ghost-button selected-category-clear"
-          onClick={handleClearCategories}
-          disabled={selectedCategories.size === 0}
-        >
-          Clear All
-        </button>
-      </div>
       <div className="category-list-pane">
         <button
           type="button"

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

@@ -0,0 +1,879 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import type { AudioFileSummary, CategoryRecord } from '../../../../shared/models';
+import { TagEditor } from '../TagEditor';
+import WaveformEditorCanvas from './WaveformEditorCanvas';
+import { libraryStore } from '../../stores/LibraryStore';
+import { toSplitRequest, type SegmentDraft, type SegmentMetadataDraft } from './types';
+
+export interface EditModePanelProps {
+  /** File currently being edited. */
+  file: AudioFileSummary;
+  /** Available category catalog used by the tag editor. */
+  categories: CategoryRecord[];
+  /** Invoked after the panel should be closed without committing. */
+  onClose(): void;
+  /** Invoked after a successful split with the newly created files. */
+  onSplitComplete(created: AudioFileSummary[]): void;
+}
+
+const MIN_SEGMENT_MS = 50;
+
+type PlaybackMode = 'segment' | 'cursor';
+
+interface PlaybackInfo {
+  mode: PlaybackMode;
+  startMs: number;
+  endMs: number | null;
+  label: string;
+  segmentId: string | null;
+  pausedOffsetMs: number;
+}
+
+interface PlaybackUiState {
+  mode: PlaybackMode;
+  label: string;
+  startMs: number;
+  endMs: number | null;
+  isPlaying: boolean;
+}
+
+/**
+ * Full-screen overlay that enables waveform driven segment editing and metadata assignment before splitting.
+ */
+export function EditModePanel({ file, categories, onClose, onSplitComplete }: EditModePanelProps): JSX.Element {
+  const [waveformSamples, setWaveformSamples] = useState<number[] | null>(null);
+  const [waveformError, setWaveformError] = useState<string | null>(null);
+  const [durationMs, setDurationMs] = useState<number | null>(file.durationMs ?? null);
+  const [segments, setSegments] = useState<SegmentDraft[]>([]);
+  const [selectedSegmentId, setSelectedSegmentId] = useState<string | null>(null);
+  const [isSaving, setIsSaving] = useState(false);
+  const [submitError, setSubmitError] = useState<string | null>(null);
+  const [baseMetadata, setBaseMetadata] = useState<{ author: string | null; rating: number | null }>(
+    () => ({ author: null, rating: null })
+  );
+  const audioContextRef = useRef<AudioContext | null>(null);
+  const audioBufferRef = useRef<AudioBuffer | null>(null);
+  const audioBufferPromiseRef = useRef<Promise<AudioBuffer | null> | null>(null);
+  const activeSourceRef = useRef<AudioBufferSourceNode | null>(null);
+  const playbackStartTimeRef = useRef<number | null>(null);
+  const playbackInfoRef = useRef<PlaybackInfo | null>(null);
+  const activePlaybackIdRef = useRef<string | null>(null);
+  const lastSegmentPlayRef = useRef<{ segmentId: string; timestamp: number } | null>(null);
+  const playbackCursorFrameRef = useRef<number | null>(null);
+  const [playbackCursorMs, setPlaybackCursorMs] = useState<number | null>(null);
+  const [playbackUi, setPlaybackUi] = useState<PlaybackUiState | null>(null);
+
+  const ensureAudioContext = useCallback((): AudioContext | null => {
+    if (audioContextRef.current) {
+      return audioContextRef.current;
+    }
+    const globalWindow = window as typeof window & { webkitAudioContext?: typeof AudioContext };
+    const AudioContextCtor = globalWindow.AudioContext ?? globalWindow.webkitAudioContext;
+    if (!AudioContextCtor) {
+      setWaveformError((current) => current ?? 'Audio playback is not supported in this environment.');
+      return null;
+    }
+    audioContextRef.current = new AudioContextCtor();
+    return audioContextRef.current;
+  }, []);
+
+  const stopActiveSource = useCallback(() => {
+    const source = activeSourceRef.current;
+    if (!source) {
+      return;
+    }
+    source.onended = null;
+    try {
+      source.stop();
+    } catch (error) {
+      // Ignore errors when the source has already completed playback.
+    }
+    source.disconnect();
+    activeSourceRef.current = null;
+  }, []);
+
+  const stopPlaybackCursorTracking = useCallback((options?: { preservePosition?: boolean }) => {
+    if (playbackCursorFrameRef.current !== null) {
+      cancelAnimationFrame(playbackCursorFrameRef.current);
+      playbackCursorFrameRef.current = null;
+    }
+    if (!options?.preservePosition) {
+      setPlaybackCursorMs(null);
+    }
+  }, []);
+
+  const schedulePlaybackCursorUpdate = useCallback(() => {
+    const context = audioContextRef.current;
+    const info = playbackInfoRef.current;
+    if (!context || !info || playbackStartTimeRef.current === null) {
+      stopPlaybackCursorTracking();
+      return;
+    }
+
+    const elapsedMs = Math.max(0, (context.currentTime - playbackStartTimeRef.current) * 1000);
+    const buffer = audioBufferRef.current;
+    const bufferDurationMs = buffer ? buffer.duration * 1000 : Number.POSITIVE_INFINITY;
+    const absoluteEndMs = info.endMs ?? bufferDurationMs;
+    const position = info.startMs + info.pausedOffsetMs + elapsedMs;
+    const clampedPosition = Math.min(position, absoluteEndMs);
+    setPlaybackCursorMs(clampedPosition);
+
+    if (position >= absoluteEndMs) {
+      stopPlaybackCursorTracking({ preservePosition: true });
+      return;
+    }
+
+    playbackCursorFrameRef.current = window.requestAnimationFrame(schedulePlaybackCursorUpdate);
+  }, [stopPlaybackCursorTracking]);
+
+  const cancelPlayback = useCallback(() => {
+    stopActiveSource();
+    activePlaybackIdRef.current = null;
+    playbackStartTimeRef.current = null;
+    playbackInfoRef.current = null;
+    stopPlaybackCursorTracking();
+    setPlaybackUi(null);
+  }, [stopActiveSource, stopPlaybackCursorTracking]);
+
+  const loadAudioBuffer = useCallback(async (): Promise<AudioBuffer | null> => {
+    if (audioBufferRef.current) {
+      return audioBufferRef.current;
+    }
+    if (audioBufferPromiseRef.current) {
+      return audioBufferPromiseRef.current;
+    }
+    const context = ensureAudioContext();
+    if (!context) {
+      return null;
+    }
+    const promise = (async () => {
+      try {
+  const payload = await window.api.getAudioBuffer(file.id);
+  const buffer = await context.decodeAudioData(payload.buffer.slice(0));
+  audioBufferRef.current = buffer;
+  return buffer;
+      } catch (error) {
+        console.error('Failed to decode audio buffer for playback', error);
+        return null;
+      } finally {
+        audioBufferPromiseRef.current = null;
+      }
+    })();
+    audioBufferPromiseRef.current = promise;
+    return promise;
+  }, [ensureAudioContext, file.id]);
+
+  const beginPlayback = useCallback(
+    async (request: PlaybackInfo) => {
+      try {
+        const buffer = await loadAudioBuffer();
+        if (!buffer) {
+          return;
+        }
+        const context = ensureAudioContext();
+        if (!context) {
+          return;
+        }
+        await context.resume();
+
+        stopActiveSource();
+
+        const bufferDurationMs = buffer.duration * 1000;
+        const absoluteEndMs = request.endMs ?? bufferDurationMs;
+        const playbackStartMs = request.startMs + request.pausedOffsetMs;
+        if (playbackStartMs >= absoluteEndMs) {
+          return;
+        }
+
+        const id = generatePlaybackId();
+        const playbackLengthMs = absoluteEndMs - playbackStartMs;
+        const source = context.createBufferSource();
+        source.buffer = buffer;
+        
+        // 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 };
+        activePlaybackIdRef.current = id;
+        playbackStartTimeRef.current = context.currentTime;
+        activeSourceRef.current = source;
+        stopPlaybackCursorTracking({ preservePosition: true });
+        setPlaybackCursorMs(request.startMs + request.pausedOffsetMs);
+        schedulePlaybackCursorUpdate();
+        
+        setPlaybackUi({
+          mode: request.mode,
+          label: request.label,
+          startMs: request.startMs,
+          endMs: request.endMs,
+          isPlaying: true
+        });
+
+        source.onended = () => {
+          if (activePlaybackIdRef.current === id) {
+            const infoSnapshot = playbackInfoRef.current;
+            const buffer = audioBufferRef.current;
+            const bufferDurationMs = buffer ? buffer.duration * 1000 : Number.POSITIVE_INFINITY;
+            const finalPosition = infoSnapshot ? (infoSnapshot.endMs ?? bufferDurationMs) : null;
+            if (finalPosition !== null && Number.isFinite(finalPosition)) {
+              setPlaybackCursorMs(finalPosition);
+            }
+            stopPlaybackCursorTracking({ preservePosition: true });
+            activePlaybackIdRef.current = null;
+            playbackStartTimeRef.current = null;
+            playbackInfoRef.current = null;
+            activeSourceRef.current = null;
+            setPlaybackUi(null);
+          }
+        };
+      } catch (error) {
+        console.error('Playback start failed', error);
+        stopPlaybackCursorTracking();
+      }
+    },
+    [ensureAudioContext, loadAudioBuffer, stopActiveSource, schedulePlaybackCursorUpdate, stopPlaybackCursorTracking, segments]
+  );
+
+  const pausePlayback = useCallback(() => {
+    const info = playbackInfoRef.current;
+    const context = audioContextRef.current;
+    if (!info || !context) {
+      return;
+    }
+    if (activePlaybackIdRef.current === null || playbackStartTimeRef.current === null) {
+      return;
+    }
+    const elapsedMs = (context.currentTime - playbackStartTimeRef.current) * 1000;
+    const bufferDurationMs = audioBufferRef.current ? audioBufferRef.current.duration * 1000 : Number.POSITIVE_INFINITY;
+    const absoluteEndMs = info.endMs ?? bufferDurationMs;
+    const nextOffset = Math.min(absoluteEndMs - info.startMs, info.pausedOffsetMs + elapsedMs);
+    const absolutePosition = info.startMs + nextOffset;
+    playbackInfoRef.current = { ...info, pausedOffsetMs: nextOffset };
+    activePlaybackIdRef.current = null;
+    playbackStartTimeRef.current = null;
+    stopActiveSource();
+    stopPlaybackCursorTracking({ preservePosition: true });
+    setPlaybackCursorMs(absolutePosition);
+    setPlaybackUi((current) => (current ? { ...current, isPlaying: false } : current));
+  }, [stopActiveSource, stopPlaybackCursorTracking]);
+
+  const resumePlayback = useCallback(() => {
+    const info = playbackInfoRef.current;
+    if (!info) {
+      return;
+    }
+    beginPlayback(info);
+  }, [beginPlayback]);
+
+  const togglePlayback = useCallback(() => {
+    if (activePlaybackIdRef.current) {
+      pausePlayback();
+      return;
+    }
+    if (playbackInfoRef.current) {
+      resumePlayback();
+    }
+  }, [pausePlayback, resumePlayback]);
+
+  useEffect(() => {
+    let cancelled = false;
+    setWaveformSamples(null);
+    setWaveformError(null);
+    (async () => {
+      try {
+        const preview = await window.api.getWaveformPreview(file.id, 8192);
+        if (!cancelled) {
+          setWaveformSamples(preview.samples);
+        }
+      } catch (error) {
+        console.error('Failed to load waveform preview', error);
+        if (!cancelled) {
+          setWaveformSamples([]);
+          setWaveformError('Failed to load waveform preview for this file.');
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [file.id]);
+
+  useEffect(() => {
+    let cancelled = false;
+    setSegments([]);
+    setSelectedSegmentId(null);
+    (async () => {
+      try {
+        const metadata = await window.api.readFileMetadata(file.id);
+        if (!cancelled) {
+          setBaseMetadata({
+            author: metadata.author?.trim() ?? null,
+            rating: metadata.rating ?? null
+          });
+        }
+      } catch (error) {
+        console.warn('Failed to read metadata for edit mode', error);
+        if (!cancelled) {
+          setBaseMetadata({ author: null, rating: null });
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [file.id]);
+
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      const buffer = await loadAudioBuffer();
+      if (cancelled || !buffer) {
+        return;
+      }
+      setDurationMs((current) => (current === null ? Math.round(buffer.duration * 1000) : current));
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [loadAudioBuffer]);
+
+  useEffect(() => {
+    return () => {
+      cancelPlayback();
+      const context = audioContextRef.current;
+      if (context) {
+        context.close().catch(() => undefined);
+        audioContextRef.current = null;
+      }
+    };
+  }, [cancelPlayback]);
+
+  const selectedSegment = useMemo(
+    () => segments.find((segment) => segment.id === selectedSegmentId) ?? null,
+    [segments, selectedSegmentId]
+  );
+
+  const isWaveformReady = waveformSamples !== null && durationMs !== null;
+  const effectiveDuration = durationMs ?? 0;
+
+  const playSegment = useCallback(
+    (segment: SegmentDraft) => {
+      const trimmedLabel = segment.label.trim();
+      const label = trimmedLabel.length > 0
+        ? trimmedLabel
+        : `${formatTimecode(segment.startMs)} → ${formatTimecode(segment.endMs)}`;
+      beginPlayback({
+        mode: 'segment',
+        startMs: segment.startMs,
+        endMs: segment.endMs,
+        label,
+        segmentId: segment.id,
+        pausedOffsetMs: 0
+      });
+    },
+    [beginPlayback]
+  );
+
+  const playFromCursor = useCallback(
+    (startMs: number) => {
+      beginPlayback({
+        mode: 'cursor',
+        startMs,
+        endMs: null,
+        label: `From ${formatTimecode(startMs)}`,
+        segmentId: null,
+        pausedOffsetMs: 0
+      });
+    },
+    [beginPlayback]
+  );
+
+  const handleClose = useCallback(() => {
+    cancelPlayback();
+    onClose();
+  }, [cancelPlayback, onClose]);
+
+  const handleCreateSegment = (rawStart: number, rawEnd: number) => {
+    if (!isWaveformReady) {
+      return;
+    }
+    const { start, end } = normaliseRange(rawStart, rawEnd, effectiveDuration);
+    const newSegment: SegmentDraft = {
+      id: generateSegmentId(),
+      startMs: start,
+      endMs: end,
+      label: `Segment ${segments.length + 1}`,
+      metadata: buildDefaultMetadata(file, baseMetadata),
+      color: generateSegmentColor(segments.length),
+      fadeInMs: 0,
+      fadeOutMs: 0
+    };
+    setSegments((current) => {
+      const next = [...current, newSegment].sort((a, b) => a.startMs - b.startMs);
+      return next;
+    });
+    setSelectedSegmentId(newSegment.id);
+    playSegment(newSegment);
+  };
+
+  const handleResizeSegment = (segmentId: string, rawStart: number, rawEnd: number) => {
+    if (!isWaveformReady) {
+      return;
+    }
+    const { start, end } = normaliseRange(rawStart, rawEnd, effectiveDuration);
+    setSegments((current) => {
+      const next = current.map((segment) =>
+        segment.id === segmentId
+          ? { ...segment, startMs: start, endMs: end }
+          : segment
+      );
+      next.sort((a, b) => a.startMs - b.startMs);
+      return next;
+    });
+  };
+
+  const handleSelectSegment = useCallback((segmentId: string | null) => {
+    setSelectedSegmentId(segmentId);
+    if (!segmentId) {
+      return;
+    }
+    const segment = segments.find((entry) => entry.id === segmentId);
+    if (segment) {
+      const now = performance.now();
+      const lastPlay = lastSegmentPlayRef.current;
+      const recentlyStartedSameSegment =
+        lastPlay &&
+        lastPlay.segmentId === segmentId &&
+        now - lastPlay.timestamp < 500;
+      
+      if (!recentlyStartedSameSegment) {
+        playSegment(segment);
+        lastSegmentPlayRef.current = {
+          segmentId,
+          timestamp: now
+        };
+      }
+    }
+  }, [segments, playSegment]);
+
+  const handleUpdateLabel = (segmentId: string, label: string) => {
+    setSegments((current) =>
+      current.map((segment) =>
+        segment.id === segmentId
+          ? { ...segment, label }
+          : segment
+      )
+    );
+  };
+
+  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));
+    if (playbackInfoRef.current?.segmentId === segmentId) {
+      cancelPlayback();
+    }
+  }, [cancelPlayback]);
+
+  const handleMetadataPatch = (segmentId: string, patch: Partial<SegmentMetadataDraft>) => {
+    setSegments((current) =>
+      current.map((segment) =>
+        segment.id === segmentId
+          ? { ...segment, metadata: { ...segment.metadata, ...patch } }
+          : segment
+      )
+    );
+  };
+
+  useEffect(() => {
+    const handleKeyDown = (event: KeyboardEvent) => {
+      const activeElement = document.activeElement;
+      if (activeElement && (activeElement.tagName === 'INPUT' || activeElement.tagName === 'TEXTAREA' || activeElement.getAttribute('contenteditable') === 'true')) {
+        return;
+      }
+
+      if (event.key === 'Delete') {
+        if (selectedSegmentId) {
+          event.preventDefault();
+          handleRemoveSegment(selectedSegmentId);
+        }
+        return;
+      }
+
+      if (event.code === 'Space' || event.key === ' ') {
+        event.preventDefault();
+        if (playbackInfoRef.current) {
+          togglePlayback();
+        } else if (selectedSegmentId) {
+          const segment = segments.find((seg) => seg.id === selectedSegmentId);
+          if (segment) {
+            playSegment(segment);
+          }
+        }
+      }
+    };
+
+    window.addEventListener('keydown', handleKeyDown);
+    return () => {
+      window.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [selectedSegmentId, segments, handleRemoveSegment, togglePlayback, playSegment]);
+
+  const handleCategorySave = (segmentId: string, categories: string[]) => {
+    handleMetadataPatch(segmentId, {
+      categories
+    });
+  };
+
+  const handleCommit = async () => {
+    if (segments.length === 0 || !isWaveformReady) {
+      return;
+    }
+    setSubmitError(null);
+    setIsSaving(true);
+    try {
+      const payload = segments.map((segment) => toSplitRequest(segment));
+      const created = await libraryStore.splitFile(file.id, payload);
+      onSplitComplete(created);
+      handleClose();
+    } catch (error) {
+      console.error('Split operation failed', error);
+      setSubmitError(error instanceof Error ? error.message : String(error));
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  return (
+    <div className="edit-mode-overlay" role="dialog" aria-modal="true">
+      <div className="edit-mode-panel">
+        <header className="edit-mode-header">
+          <div>
+            <h1>{file.customName || file.displayName}</h1>
+            <p>{file.relativePath}</p>
+          </div>
+          <div className="edit-mode-header-actions">
+            <button type="button" className="ghost-button" onClick={handleClose}>Close</button>
+          </div>
+        </header>
+        <div className="edit-mode-body">
+          <div className="edit-mode-waveform-container">
+            <div className="edit-mode-waveform">
+              {waveformError && <div className="edit-mode-error">{waveformError}</div>}
+              {!waveformError && !isWaveformReady && (
+                <div className="edit-mode-placeholder">Loading waveform…</div>
+              )}
+              {!waveformError && isWaveformReady && waveformSamples && (
+                <WaveformEditorCanvas
+                  samples={waveformSamples}
+                  durationMs={effectiveDuration}
+                  segments={segments}
+                  selectedSegmentId={selectedSegmentId}
+                  onSelectSegment={handleSelectSegment}
+                  onCreateSegment={handleCreateSegment}
+                  onResizeSegment={handleResizeSegment}
+                  onPlayFromCursor={playFromCursor}
+                  playbackCursorMs={playbackCursorMs}
+                  onUpdateFade={handleUpdateFade}
+                />
+              )}
+            </div>
+            <div className="edit-mode-playback-controls">
+              {playbackUi ? (
+                <>
+                  <button
+                    type="button"
+                    className="ghost-button edit-mode-playback-toggle"
+                    onClick={togglePlayback}
+                  >
+                    {playbackUi.isPlaying ? 'Pause (Space)' : 'Play (Space)'}
+                  </button>
+                  <div className="edit-mode-playback-details">
+                    <span className="edit-mode-playback-title">{playbackUi.label}</span>
+                    <span className="edit-mode-playback-range">
+                      {formatTimecode(playbackUi.startMs)}
+                      {' → '}
+                      {formatTimecode(playbackUi.endMs ?? effectiveDuration)}
+                      {playbackUi.endMs === null ? ' (end)' : ''}
+                    </span>
+                  </div>
+                </>
+              ) : (
+                <>
+                  {selectedSegment ? (
+                    <>
+                      <button
+                        type="button"
+                        className="ghost-button edit-mode-playback-toggle"
+                        onClick={() => playSegment(selectedSegment)}
+                      >
+                        Play (Space)
+                      </button>
+                      <div className="edit-mode-playback-details">
+                        <span className="edit-mode-playback-title">
+                          {selectedSegment.label.trim() || `${formatTimecode(selectedSegment.startMs)} → ${formatTimecode(selectedSegment.endMs)}`}
+                        </span>
+                        <span className="edit-mode-playback-range">
+                          {formatTimecode(selectedSegment.startMs)}
+                          {' → '}
+                          {formatTimecode(selectedSegment.endMs)}
+                        </span>
+                      </div>
+                    </>
+                  ) : (
+                    <div className="edit-mode-playback-idle">No segment selected</div>
+                  )}
+                </>
+              )}
+            </div>
+          </div>
+          <aside className="edit-mode-sidebar">
+            <section className="segment-list">
+              <header className="segment-list-header">
+                <h2>Segments</h2>
+                <span>{segments.length}</span>
+              </header>
+              {segments.length === 0 ? (
+                <p className="segment-list-empty">Drag on the waveform to create segments.</p>
+              ) : (
+                <ul>
+                  {segments.map((segment) => (
+                    <li key={segment.id} className={segment.id === selectedSegmentId ? 'segment-item segment-item--selected' : 'segment-item'}>
+                      <span className="segment-color-indicator" style={{ backgroundColor: segment.color }} />
+                      <button
+                        type="button"
+                        className="segment-item-select"
+                        onClick={() => handleSelectSegment(segment.id)}
+                        aria-pressed={segment.id === selectedSegmentId}
+                      >
+                        <span className="segment-item-time">{formatTimecode(segment.startMs)} – {formatTimecode(segment.endMs)}</span>
+                      </button>
+                      <div className="segment-item-label-row">
+                        <input
+                          type="text"
+                          value={segment.label}
+                          onChange={(event) => handleUpdateLabel(segment.id, event.target.value)}
+                          placeholder="Segment Name"
+                        />
+                        {segment.id === selectedSegmentId && (
+                          <button
+                            type="button"
+                            className="segment-item-delete"
+                            onClick={() => handleRemoveSegment(segment.id)}
+                            aria-label="Delete segment"
+                            title="Delete segment"
+                          >
+                            🗑️
+                          </button>
+                        )}
+                      </div>
+                      {segment.id === selectedSegmentId && (
+                        <div className="segment-item-metadata">
+                          <label className="segment-field">
+                            <span>Author</span>
+                            <input
+                              type="text"
+                              value={segment.metadata.author ?? ''}
+                              onChange={(event) => handleMetadataPatch(segment.id, { author: normaliseText(event.target.value) })}
+                              placeholder="Artist or creator"
+                            />
+                          </label>
+                          <div className="segment-field">
+                            <span>Rating</span>
+                            <div className="star-rating">
+                              {[1, 2, 3, 4, 5].map((star) => (
+                                <button
+                                  key={star}
+                                  type="button"
+                                  className={segment.metadata.rating !== null && segment.metadata.rating >= star ? 'star star--filled' : 'star'}
+                                  onClick={() => handleMetadataPatch(segment.id, {
+                                    rating: segment.metadata.rating === star ? null : star
+                                  })}
+                                  aria-label={`${star} star${star > 1 ? 's' : ''}`}
+                                >
+                                  ★
+                                </button>
+                              ))}
+                            </div>
+                          </div>
+                          <div className="segment-field">
+                            <span>Categories</span>
+                            <TagEditor
+                              categories={segment.metadata.categories}
+                              availableCategories={categories}
+                              onSave={(nextCategories) => handleCategorySave(segment.id, nextCategories)}
+                              showHeading={false}
+                            />
+                          </div>
+                        </div>
+                      )}
+                    </li>
+                  ))}
+                </ul>
+              )}
+            </section>
+            <section className="segment-metadata">
+              <h2>Metadata</h2>
+              {selectedSegment ? (
+                <p className="segment-metadata-helper">Edit segment metadata in the segment list above.</p>
+              ) : (
+                <p className="segment-metadata-empty">Select a segment to edit its metadata.</p>
+              )}
+            </section>
+          </aside>
+        </div>
+        <footer className="edit-mode-footer">
+          {submitError && <span className="edit-mode-error">{submitError}</span>}
+          <div className="edit-mode-footer-actions">
+            <button type="button" className="ghost-button" onClick={handleClose} disabled={isSaving}>Cancel</button>
+            <button
+              type="button"
+              className="primary-button"
+              onClick={handleCommit}
+              disabled={isSaving || segments.length === 0 || !isWaveformReady}
+            >
+              {isSaving ? 'Splitting…' : `Create ${segments.length} segment${segments.length === 1 ? '' : 's'}`}
+            </button>
+          </div>
+        </footer>
+      </div>
+    </div>
+  );
+}
+
+function normaliseRange(start: number, end: number, duration: number): { start: number; end: number } {
+  let safeStart = Math.max(0, Math.min(start, duration - MIN_SEGMENT_MS));
+  let safeEnd = Math.max(safeStart + MIN_SEGMENT_MS, Math.min(end, duration));
+  if (safeEnd > duration) {
+    safeEnd = duration;
+    safeStart = Math.max(0, safeEnd - MIN_SEGMENT_MS);
+  }
+  return { start: safeStart, end: safeEnd };
+}
+
+function generatePlaybackId(): string {
+  if (typeof window !== 'undefined' && window.crypto?.randomUUID) {
+    return window.crypto.randomUUID();
+  }
+  return `playback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function buildDefaultMetadata(
+  file: AudioFileSummary,
+  baseMetadata: { author: string | null; rating: number | null }
+): SegmentMetadataDraft {
+  return {
+    customName: null,
+    author: baseMetadata.author,
+    rating: baseMetadata.rating,
+    tags: file.tags.slice(),
+    categories: file.categories.slice()
+  };
+}
+
+function generateSegmentId(): string {
+  if (typeof window !== 'undefined' && window.crypto?.randomUUID) {
+    return window.crypto.randomUUID();
+  }
+  return `segment-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function generateSegmentColor(index: number): string {
+  // Use 36-degree spacing on hue wheel (360/36 = 10 unique colors per cycle)
+  const hue = (index * 36) % 360;
+  const saturation = 70;
+  const lightness = 65;
+  return hslToHex(hue, saturation, lightness);
+}
+
+function hslToHex(h: number, s: number, l: number): string {
+  const sNorm = s / 100;
+  const lNorm = l / 100;
+  const c = (1 - Math.abs(2 * lNorm - 1)) * sNorm;
+  const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+  const m = lNorm - c / 2;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  
+  if (h >= 0 && h < 60) {
+    r = c; g = x; b = 0;
+  } else if (h >= 60 && h < 120) {
+    r = x; g = c; b = 0;
+  } else if (h >= 120 && h < 180) {
+    r = 0; g = c; b = x;
+  } else if (h >= 180 && h < 240) {
+    r = 0; g = x; b = c;
+  } else if (h >= 240 && h < 300) {
+    r = x; g = 0; b = c;
+  } else if (h >= 300 && h < 360) {
+    r = c; g = 0; b = x;
+  }
+  
+  const toHex = (n: number) => {
+    const hex = Math.round((n + m) * 255).toString(16);
+    return hex.length === 1 ? '0' + hex : hex;
+  };
+  
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+
+function normaliseText(value: string): string | null {
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+
+function formatTimecode(ms: number): string {
+  if (!Number.isFinite(ms) || ms < 0) {
+    return '00:00.000';
+  }
+  const totalSeconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  const milliseconds = Math.floor(ms % 1000);
+  return `${minutes.toString().padStart(2, '0')}:${seconds
+    .toString()
+    .padStart(2, '0')}.${milliseconds.toString().padStart(3, '0')}`;
+}
+
+export default EditModePanel;

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

@@ -0,0 +1,68 @@
+import type { SplitSegmentRequest } from '../../../../shared/models';
+
+/**
+ * Editable metadata captured for each draft segment.
+ */
+export interface SegmentMetadataDraft {
+  /** Custom name override applied to the generated segment (null clears). */
+  customName: string | null;
+  /** Author/artist override applied to the generated segment. */
+  author: string | null;
+  /** Rating override (1-5) applied to the generated segment, null preserves none. */
+  rating: number | null;
+  /** Tag collection applied to the generated segment. */
+  tags: string[];
+  /** UCS categories applied to the generated segment. */
+  categories: string[];
+}
+
+/**
+ * Draft segment structure maintained inside the edit mode panel before saving.
+ */
+export interface SegmentDraft {
+  /** Stable identifier used for React rendering and user interactions. */
+  id: string;
+  /** Inclusive start offset in milliseconds. */
+  startMs: number;
+  /** Exclusive end offset in milliseconds. */
+  endMs: number;
+  /** User facing label displayed in the segment list. */
+  label: string;
+  /** Captured metadata overrides. */
+  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;
+}
+
+/**
+ * Converts a draft segment into the IPC request payload.
+ */
+export function toSplitRequest(segment: SegmentDraft): SplitSegmentRequest {
+  const trimmedLabel = segment.label.trim();
+  const effectiveLabel = trimmedLabel.length > 0 ? trimmedLabel : undefined;
+  
+  // Only include customName in metadata if it differs from the label
+  // This allows the backend to use the label as the customName by default
+  const customNameOverride = segment.metadata.customName !== null && segment.metadata.customName !== trimmedLabel
+    ? segment.metadata.customName
+    : undefined;
+  
+  return {
+    startMs: Math.round(segment.startMs),
+    endMs: Math.round(segment.endMs),
+    label: effectiveLabel,
+    metadata: {
+      customName: customNameOverride,
+      author: segment.metadata.author,
+      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

@@ -3,6 +3,7 @@ import type {
   AudioFileSummary,
   CategoryRecord,
   LibraryScanSummary,
+  SplitSegmentRequest,
   TagUpdatePayload
 } from '../../../shared/models';
 
@@ -206,6 +207,36 @@ export class LibraryStore extends EventTarget {
     this.emitChange();
   }
 
+  /**
+   * Clears active filters, refreshes the file cache, and selects the requested file.
+   */
+  public async focusOnFile(fileId: number): Promise<void> {
+    if (!Number.isFinite(fileId)) {
+      return;
+    }
+
+    const files = await window.api.listAudioFiles();
+    if (!files.some((file) => file.id === fileId)) {
+      return;
+    }
+
+    this.snapshot = {
+      ...this.snapshot,
+      files,
+      searchQuery: '',
+      categoryFilter: null
+    };
+    this.refreshVisibleFiles(fileId, false);
+    const focused = this.snapshot.files.find((file) => file.id === fileId) ?? null;
+    this.snapshot = {
+      ...this.snapshot,
+      selectedFileId: fileId,
+      selectedFileIds: new Set([fileId]),
+      focusedFile: focused
+    };
+    this.emitChange();
+  }
+
   /**
    * Executes a fuzzy search request.
    */
@@ -297,7 +328,7 @@ export class LibraryStore extends EventTarget {
   /**
    * Automatically organizes a file based on its categories.
    */
-  public async organizeFile(fileId: number, metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }): Promise<AudioFileSummary> {
+  public async organizeFile(fileId: number, metadata: { customName?: string | null; author?: string | null; rating?: number }): Promise<AudioFileSummary> {
     const currentSelection = this.snapshot.selectedFileId;
     const currentFocused = this.snapshot.focusedFile;
     const updated = await window.api.organizeFile(fileId, metadata);
@@ -335,9 +366,9 @@ export class LibraryStore extends EventTarget {
   }
 
   /**
-   * Updates metadata (author, copyright, rating) for a file without organizing it.
+   * Updates metadata (author, rating) for a file without organizing it.
    */
-  public async updateFileMetadata(fileId: number, metadata: { author?: string | null; copyright?: string | null; rating?: number }): Promise<void> {
+  public async updateFileMetadata(fileId: number, metadata: { author?: string | null; rating?: number }): Promise<void> {
     await window.api.updateFileMetadata(fileId, metadata);
     
     // Refresh the file list to get updated metadata
@@ -361,6 +392,32 @@ export class LibraryStore extends EventTarget {
     this.emitChange();
   }
 
+  /**
+   * Splits a file into multiple segments and refreshes the library snapshot.
+   */
+  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();
+    }
+
+    this.snapshot = {
+      ...this.snapshot,
+      files,
+      visibleFiles: visible,
+      metadataSuggestionsVersion: this.snapshot.metadataSuggestionsVersion + 1
+    };
+    this.emitChange();
+    return created;
+  }
+
   /**
    * Assigns a new library path and refreshes the cached settings + file list.
    */

src/renderer/src/styles/app.css

@@ -8,16 +8,6 @@
 body {
   margin: 0;
   background-color: #0c0f13;
-  user-select: none;
-  -webkit-user-select: none;
-}
-
-input,
-textarea,
-select,
-[contenteditable='true'] {
-  user-select: text;
-  -webkit-user-select: text;
 }
 
 * {
@@ -318,6 +308,7 @@ select,
 
 .file-list-search .search-input {
   width: 100%;
+  box-sizing: border-box;
 }
 
 .file-list-items {
@@ -429,6 +420,55 @@ select,
   overflow: hidden;
 }
 
+.detail-tabs {
+  display: flex;
+  gap: 0.25rem;
+  padding: 0.5rem 0.5rem 0 0.5rem;
+  background: rgba(255, 255, 255, 0.02);
+  border-bottom: 1px solid rgba(255, 255, 255, 0.06);
+}
+
+.detail-tab {
+  padding: 0.5rem 1.25rem;
+  border: 1px solid transparent;
+  border-bottom: none;
+  border-radius: 0.5rem 0.5rem 0 0;
+  background: transparent;
+  color: rgba(255, 255, 255, 0.6);
+  font: inherit;
+  font-size: 0.9rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.2s ease;
+  position: relative;
+}
+
+.detail-tab:hover:not(:disabled) {
+  background: rgba(255, 255, 255, 0.05);
+  color: rgba(255, 255, 255, 0.8);
+}
+
+.detail-tab:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+.detail-tab--active {
+  background: rgba(39, 110, 241, 0.15);
+  border-color: rgba(39, 110, 241, 0.3);
+  color: #eef3f8;
+}
+
+.detail-tab--active::after {
+  content: '';
+  position: absolute;
+  bottom: -1px;
+  left: 0;
+  right: 0;
+  height: 2px;
+  background: #276ef1;
+}
+
 .file-detail {
   flex: 1;
   overflow-y: auto;
@@ -482,6 +522,23 @@ select,
   opacity: 0.7;
 }
 
+.file-parent-link {
+  margin-top: 0.25rem;
+  padding: 0;
+  border: none;
+  background: none;
+  color: #6aa8ff;
+  font-size: 0.85rem;
+  cursor: pointer;
+  text-align: left;
+  transition: color 0.15s ease;
+}
+
+.file-parent-link:hover {
+  color: #9bc4ff;
+  text-decoration: underline;
+}
+
 .file-meta-grid {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -745,11 +802,11 @@ select,
   display: flex;
   align-items: flex-start;
   justify-content: space-between;
-  gap: 0.75rem;
+  gap: 0.5rem;
-  border: 1px solid rgba(255, 255, 255, 0.08);
+  border: none;
   border-radius: 0.6rem;
-  padding: 0.65rem 0.75rem;
+  padding: 0;
-  background: rgba(12, 16, 22, 0.65);
+  background: transparent;
 }
 
 .selected-category-chip-list {
@@ -768,21 +825,20 @@ select,
   display: flex;
   align-items: center;
   gap: 0.55rem;
-  border-radius: 999px;
+  border-radius: 6px;
   border: 1px solid var(--category-color-base, rgba(39, 110, 241, 0.5));
   background: var(--category-color-soft, rgba(39, 110, 241, 0.2));
   color: var(--category-color-text, inherit);
-  padding: 0.35rem 0.8rem;
+  padding: 0.35rem 0.5rem;
   font-size: 0.82rem;
   cursor: pointer;
-  transition: background 0.15s ease, transform 0.15s ease;
+  transition: background 0.15s ease;
   max-width: 100%;
   flex-wrap: wrap;
 }
 
 .selected-category-chip:hover {
   background: var(--category-color-strong, rgba(39, 110, 241, 0.35));
-  transform: translateY(-1px);
 }
 
 .selected-category-chip-label {
@@ -1564,3 +1620,342 @@ select,
     gap: 1rem;
   }
 }
+
+/* Edit Mode Styles */
+.edit-mode-overlay {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  width: 100%;
+  overflow: hidden;
+}
+
+.edit-mode-panel {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  background: rgba(12, 16, 22, 0.95);
+}
+
+.edit-mode-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 1rem 1.25rem;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+  flex-shrink: 0;
+}
+
+.edit-mode-header h1 {
+  margin: 0;
+  font-size: 1.1rem;
+  font-weight: 600;
+}
+
+.edit-mode-header p {
+  margin: 0.25rem 0 0 0;
+  font-size: 0.85rem;
+  opacity: 0.6;
+}
+
+.edit-mode-header-actions {
+  display: flex;
+  gap: 0.5rem;
+}
+
+.edit-mode-body {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.edit-mode-waveform-container {
+  display: flex;
+  flex-direction: column;
+  height: 540px;
+  width: 100%;
+}
+
+.edit-mode-waveform {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(0, 0, 0, 0.2);
+  position: relative;
+  width: 100%;
+  min-height: 0;
+}
+
+.edit-mode-playback-controls {
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  padding: 0.75rem 1rem;
+  background: rgba(15, 19, 25, 0.95);
+  border-top: 1px solid rgba(255, 255, 255, 0.08);
+  min-height: 3.5rem;
+}
+
+.edit-mode-playback-toggle {
+  font-weight: 600;
+  padding: 0.5rem 1rem;
+  border-radius: 0.5rem;
+  flex-shrink: 0;
+}
+
+.edit-mode-playback-details {
+  display: flex;
+  flex-direction: column;
+  gap: 0.2rem;
+  flex: 1;
+  min-width: 0;
+}
+
+.edit-mode-playback-title {
+  font-size: 0.95rem;
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.edit-mode-playback-range {
+  font-family: 'Consolas', 'Monaco', monospace;
+  font-size: 0.85rem;
+  opacity: 0.7;
+}
+
+.edit-mode-playback-idle {
+  font-size: 0.9rem;
+  opacity: 0.5;
+  font-style: italic;
+}
+
+.edit-mode-waveform canvas {
+  width: 100%;
+  height: 100%;
+  display: block;
+}
+
+.edit-mode-error,
+.edit-mode-placeholder {
+  padding: 2rem;
+  text-align: center;
+  opacity: 0.6;
+}
+
+.edit-mode-sidebar {
+  flex-shrink: 0;
+  max-height: 50%;
+  overflow-y: auto;
+  border-top: 1px solid rgba(255, 255, 255, 0.08);
+  padding: 1rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+.segment-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+}
+
+.segment-list-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.segment-list-header h2 {
+  margin: 0;
+  font-size: 0.9rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  opacity: 0.8;
+}
+
+.segment-list-header span {
+  font-size: 0.85rem;
+  opacity: 0.6;
+  background: rgba(255, 255, 255, 0.08);
+  padding: 0.2rem 0.5rem;
+  border-radius: 0.25rem;
+}
+
+.segment-list-empty {
+  padding: 1.5rem;
+  text-align: center;
+  opacity: 0.5;
+  font-size: 0.9rem;
+}
+
+.segment-list ul {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.segment-item {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  padding: 0.75rem;
+  background: rgba(255, 255, 255, 0.03);
+  border: 1px solid rgba(255, 255, 255, 0.06);
+  border-radius: 0.5rem;
+  transition: all 0.2s ease;
+  position: relative;
+  max-width: 100%;
+}
+
+.segment-item--selected {
+  background: rgba(39, 110, 241, 0.15);
+  border-color: rgba(39, 110, 241, 0.3);
+}
+
+.segment-color-indicator {
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: 4px;
+  border-radius: 0.5rem 0 0 0.5rem;
+}
+
+.segment-item-select {
+  all: unset;
+  cursor: pointer;
+  display: block;
+}
+
+.segment-item-time {
+  font-size: 0.9rem;
+  font-family: 'Consolas', 'Monaco', monospace;
+  opacity: 0.9;
+}
+
+.segment-item-label-row {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+}
+
+.segment-item input[type="text"] {
+  flex: 1;
+  padding: 0.4rem 0.6rem;
+  border-radius: 0.35rem;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  background: rgba(12, 16, 22, 0.9);
+  color: inherit;
+  font: inherit;
+  font-size: 0.9rem;
+}
+
+.segment-item-remove {
+  align-self: flex-start;
+  font-size: 0.85rem;
+  padding: 0.3rem 0.6rem;
+}
+
+.segment-metadata {
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+}
+
+.segment-metadata h2 {
+  margin: 0;
+  font-size: 0.9rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  opacity: 0.8;
+}
+
+.segment-item-delete {
+  flex-shrink: 0;
+  background: rgba(255, 59, 59, 0.15);
+  border: 1px solid rgba(255, 59, 59, 0.3);
+  color: #ff6b6b;
+  padding: 0.4rem 0.6rem;
+  border-radius: 0.35rem;
+  cursor: pointer;
+  font-size: 1rem;
+  transition: all 0.2s ease;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.segment-item-delete:hover {
+  background: rgba(255, 59, 59, 0.25);
+  border-color: rgba(255, 59, 59, 0.5);
+  transform: scale(1.05);
+}
+
+.segment-item-delete:active {
+  transform: scale(0.95);
+}
+
+.segment-field {
+  display: flex;
+  flex-direction: column;
+  gap: 0.4rem;
+}
+
+.segment-field span {
+  font-size: 0.85rem;
+  opacity: 0.7;
+}
+
+.segment-field input[type="text"],
+.segment-field input[type="number"] {
+  padding: 0.5rem 0.7rem;
+  border-radius: 0.35rem;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  background: rgba(12, 16, 22, 0.9);
+  color: inherit;
+  font: inherit;
+}
+
+.star-rating {
+  display: flex;
+  gap: 0.25rem;
+}
+
+.star {
+  all: unset;
+  cursor: pointer;
+  font-size: 1.25rem;
+  opacity: 0.3;
+  transition: opacity 0.15s ease, transform 0.15s ease;
+}
+
+.star:hover {
+  opacity: 0.6;
+  transform: scale(1.1);
+}
+
+.star--filled {
+  opacity: 1;
+  color: #f59e0b;
+}
+
+.segment-actions {
+  display: flex;
+  gap: 0.5rem;
+  padding: 1rem 1.25rem;
+  border-top: 1px solid rgba(255, 255, 255, 0.08);
+  justify-content: flex-end;
+  flex-shrink: 0;
+}
+

src/shared/ipc.ts

@@ -5,6 +5,7 @@ export const IPC_CHANNELS = {
   dialogSelectLibrary: 'dialog:select-library',
   libraryScan: 'library:scan',
   libraryList: 'library:list',
+  libraryGetById: 'library:get-by-id',
   libraryDuplicates: 'library:duplicates',
   libraryRename: 'library:rename',
   libraryMove: 'library:move',
@@ -12,6 +13,7 @@ export const IPC_CHANNELS = {
   libraryCustomName: 'library:custom-name',
   libraryOpenFolder: 'library:open-folder',
   libraryDelete: 'library:delete',
+  librarySplit: 'library:split',
   libraryBuffer: 'library:buffer',
   libraryMetadata: 'library:metadata',
   libraryMetadataSuggestions: 'library:metadata-suggestions',
@@ -38,6 +40,8 @@ export interface RendererApi {
   rescanLibrary(): Promise<import('./models').LibraryScanSummary>;
   /** Fetches the current list of audio files. */
   listAudioFiles(): Promise<import('./models').AudioFileSummary[]>;
+  /** 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. */
@@ -45,18 +49,23 @@ export interface RendererApi {
   /** Moves a file to another subdirectory under the library root. */
   moveFile(fileId: number, targetRelativeDirectory: string): Promise<import('./models').AudioFileSummary>;
   /** Automatically organizes a file based on its categories. */
-  organizeFile(fileId: number, metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }): Promise<import('./models').AudioFileSummary>;
+  organizeFile(
+    fileId: number,
+    metadata: { customName?: string | null; author?: string | null; copyright?: string | null; rating?: number }
+  ): Promise<import('./models').AudioFileSummary>;
   /** Updates the custom name for a file. */
   updateCustomName(fileId: number, customName: string | null): Promise<import('./models').AudioFileSummary>;
   /** Opens the file's containing folder in the system file explorer. */
   openFileFolder(fileId: number): Promise<void>;
   /** Deletes files from disk and database. */
   deleteFiles(fileIds: number[]): Promise<void>;
+  /** Splits an audio file into segment files. */
+  splitFile(fileId: number, segments: import('./models').SplitSegmentRequest[]): Promise<import('./models').AudioFileSummary[]>;
   /** Fetches the binary data required for playback. */
   getAudioBuffer(fileId: number): Promise<import('./models').AudioBufferPayload>;
   /** Returns a lightweight waveform preview for rendering list backgrounds. */
   getWaveformPreview(fileId: number, pointCount?: number): Promise<{ samples: number[]; rms: number }>;
-  /** Updates free-form tags and UCS categories. */
+  /** Updates UCS categories for a file (free-form tags are preserved unless explicitly provided). */
   updateTagging(payload: import('./models').TagUpdatePayload): Promise<import('./models').AudioFileSummary>;
   /** Returns the catalog of UCS categories. */
   listCategories(): Promise<import('./models').CategoryRecord[]>;
@@ -67,7 +76,10 @@ export interface RendererApi {
   /** Lists distinct metadata values gathered from the library for quick suggestions. */
   listMetadataSuggestions(): Promise<{ authors: string[]; copyrights: string[] }>;
   /** Updates metadata (author, copyright, rating) without organizing the file. */
-  updateFileMetadata(fileId: number, metadata: { author?: string | null; copyright?: string | null; rating?: number }): Promise<void>;
+  updateFileMetadata(
+    fileId: number,
+    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;
 }

src/shared/models.ts

@@ -26,6 +26,8 @@ export interface AudioFileSummary {
   bitDepth: number | null;
   /** Content checksum used for duplicate detection. */
   checksum: string | null;
+  /** Identifier of the source file this entry originated from, if any. */
+  parentFileId: number | null;
   /** Applied descriptive tags. */
   tags: string[];
   /** Associated UCS categories. */
@@ -90,8 +92,8 @@ export interface AppSettings {
 export interface TagUpdatePayload {
   /** Target audio file id. */
   fileId: number;
-  /** Free-form tag collection. */
+  /** Optional free-form tag collection. When omitted, existing tags are preserved. */
-  tags: string[];
+  tags?: string[];
   /** UCS category identifiers to attach. */
   categories: string[];
 }
@@ -107,3 +109,37 @@ export interface AudioBufferPayload {
   /** MIME type for the audio data. */
   mimeType: string;
 }
+
+/**
+ * Optional metadata overrides applied while creating split segments.
+ */
+export interface SegmentMetadataInput {
+  /** Overrides the custom name embedded into the segment (null clears it). */
+  customName?: string | null;
+  /** Overrides the author/creator metadata. */
+  author?: string | null;
+  /** Overrides the rating metadata (1-5). */
+  rating?: number;
+  /** Overrides the applied free-form tags. */
+  tags?: string[];
+  /** Overrides the applied UCS categories. */
+  categories?: string[];
+}
+
+/**
+ * Describes a region that should be extracted as a new audio segment.
+ */
+export interface SplitSegmentRequest {
+  /** Inclusive start offset in milliseconds. */
+  startMs: number;
+  /** Exclusive end offset in milliseconds. */
+  endMs: number;
+  /** Optional display label used for segment naming. */
+  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,245 +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);
-    });
-  });
-
-  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']);
-    });
-  });
-});

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));
-}

tsconfig.main.json

@@ -2,7 +2,7 @@
   "extends": "./tsconfig.base.json",
   "compilerOptions": {
     "module": "CommonJS",
-    "moduleResolution": "Node10",
+    "moduleResolution": "Node",
     "outDir": "dist/main",
     "rootDir": "src",
     "types": ["node"],