feat(cutter): add crash-safe project recovery and export profiles

Persist source-bound cutter projects atomically and expose recovery, discard, save, and open actions through the secured IPC bridge. Add explicit quality, balanced, fast, and archive export pipelines with rotation, audio-track selection, hardware encoder probing, and software fallback. Align main, preload, renderer, UI styles, and focused coverage; remove the reported main-process lint errors without changing unrelated work.

src/index.html

@@ -453,6 +453,13 @@
                                 <input type="text" id="cutterFilePath" readonly aria-labelledby="cutterSelectTitle" placeholder="Keine Datei ausgewählt…">
                             </div>
                             <button type="button" class="btn-secondary" id="cutterBrowseBtn" onclick="selectCutterVideo()">Durchsuchen</button>
+                            <button type="button" class="btn-secondary" id="cutterOpenProjectBtn" onclick="openCutterProject()" disabled>Projekt öffnen</button>
+                            <button type="button" class="btn-secondary" id="cutterSaveProjectBtn" onclick="saveCutterProject()" disabled>Projekt speichern</button>
+                        </div>
+                        <div class="cutter-recovery-panel" id="cutterRecoveryPanel" role="status" hidden>
+                            <span id="cutterRecoveryText">Gespeicherte Bearbeitung gefunden</span>
+                            <button type="button" class="btn-secondary" onclick="recoverCutterProject()">Wiederherstellen</button>
+                            <button type="button" class="btn-secondary" onclick="discardCutterProject()">Verwerfen</button>
                         </div>
 
                         <div class="cutter-workspace" id="cutterWorkspace">
@@ -474,6 +481,23 @@
                                     <input type="checkbox" id="cutterPreviewMode" checked onchange="setCutterPreviewMode(this.checked)">
                                     <span class="cutter-toggle-track" aria-hidden="true"></span>
                                 </label>
+                                <div class="cutter-export-options">
+                                    <label for="cutterExportProfile">Exportprofil</label>
+                                    <select id="cutterExportProfile" onchange="setCutterExportProfile(this.value)" disabled>
+                                        <option value="quality">Quality</option>
+                                        <option value="balanced" selected>Balanced</option>
+                                        <option value="fast">Fast</option>
+                                        <option value="archive">Archive</option>
+                                    </select>
+                                    <label for="cutterExportEncoder">Encoder</label>
+                                    <select id="cutterExportEncoder" onchange="setCutterExportEncoder(this.value)" disabled>
+                                        <option value="software">Software</option>
+                                    </select>
+                                    <label for="cutterAudioStream">Audiospur</label>
+                                    <select id="cutterAudioStream" onchange="setCutterAudioStream(this.value)" disabled>
+                                        <option value="0">Keine Audiospur</option>
+                                    </select>
+                                </div>
                                 <div class="cutter-trim-card">
                                     <div class="cutter-card-title" id="cutterGlobalTrimLabel">Gesamtauswahl</div>
                                     <div class="cutter-time-field-row">

src/main.ts

@@ -21,7 +21,7 @@ import { watchRendererChanges } from './main/dev-reload';
 import { createPausableOutput, type PausableOutput } from './main/domain/pausable-output';
 import { PartialDownloadRegistry } from './main/domain/partial-download';
 import { QueueProcessRegistry, QueueRunLifecycle, waitForChildProcessExit } from './main/queue/process-registry';
-import type { DbHandle } from './main/infra/db';
+import { openDatabase, type DbHandle } from './main/infra/db';
 import {
     normalizeLogin,
     normalizeAutoRecordPollSeconds,
@@ -40,7 +40,17 @@ import { CustomClip, MergeGroupItem, MergeGroup, QueueItem, DownloadProgress, Do
 import { buildVodPreviewFrameUrls } from './main/domain/vod-preview';
 import { getWindowsAppIdentity } from './main/domain/app-identity';
 import { addCutAt, createVideoEditorState, getPlayableSegments, setTrimRange, type EditorCut } from './main/domain/video-editor';
-import { calculateCutterExportProgress, createCutterExportPlan } from './main/domain/cutter-export';
+import {
+    calculateCutterExportProgress,
+    createCutterExportPlan,
+    CUTTER_EXPORT_PROFILES,
+    getCutterExportProfile,
+    parseCutterHardwareEncoders,
+    type CutterExportEncoder,
+    type CutterExportProfile,
+    type CutterHardwareEncoder,
+} from './main/domain/cutter-export';
+import { createCutterProjectAutosaveStore, type CutterProject, type CutterProjectSource } from './main/domain/cutter-project';
 import {
     CUTTER_SESSION_CAPABILITY_TTL_MS,
     FileCapabilityStore,
@@ -56,6 +66,7 @@ import { createExportableConfig } from './main/domain/config-export';
 import { commitQueueMutation, persistStateChange } from './main/domain/persistence-commit';
 import { resolveSecretInputUpdate } from './main/domain/secret-input';
 import { createSecretStore, type SecretStore } from './main/domain/secret-store';
+import { migrateJsonToSqlite } from './main/domain/migrator';
 import { createElectronSecureStorage } from './main/infra/secure-storage';
 import { readChatFile } from './main/domain/chat-reader';
 import {
@@ -85,6 +96,7 @@ const GITHUB_RELEASES_DOWNLOAD_BASE_URL = 'https://github.com/Sucukdeluxe/Twitch
 const APPDATA_DIR = path.join(process.env.PROGRAMDATA || 'C:\\ProgramData', 'Twitch_VOD_Manager');
 const DEBUG_LOG_FILE = path.join(APPDATA_DIR, 'debug.log');
 const PARTIAL_DOWNLOADS_FILE = path.join(APPDATA_DIR, 'partial-downloads.json');
+const CUTTER_PROJECT_AUTOSAVE_FILE = path.join(APPDATA_DIR, 'cutter-projects.json');
 const TOOLS_DIR = path.join(APPDATA_DIR, 'tools');
 const TOOLS_STREAMLINK_DIR = path.join(TOOLS_DIR, 'streamlink');
 const TOOLS_FFMPEG_DIR = path.join(TOOLS_DIR, 'ffmpeg');
@@ -141,6 +153,7 @@ if (!fs.existsSync(APPDATA_DIR)) {
     fs.mkdirSync(APPDATA_DIR, { recursive: true });
 }
 const partialDownloadRegistry = new PartialDownloadRegistry(PARTIAL_DOWNLOADS_FILE);
+const cutterProjectAutosaves = createCutterProjectAutosaveStore(CUTTER_PROJECT_AUTOSAVE_FILE);
 
 // ==========================================
 // INTERFACES
@@ -274,6 +287,8 @@ interface VideoInfo {
     audioCodec: string | null;
     previewCompatible: boolean;
     variableFrameRate: boolean;
+    rotation: 0 | 90 | 180 | 270;
+    audioStreams: Array<{ index: number; codec: string; channels: number; language: string | null }>;
 }
 
 interface VideoEditorMedia {
@@ -312,6 +327,9 @@ interface VideoEditExportRequest {
     trimStart: number;
     trimEnd: number;
     cuts: EditorCut[];
+    profile: CutterExportProfile;
+    encoder: CutterExportEncoder;
+    audioStreamIndex: number;
 }
 
 interface RendererVideoEditExportRequest {
@@ -320,6 +338,9 @@ interface RendererVideoEditExportRequest {
     trimStart: number;
     trimEnd: number;
     cuts: EditorCut[];
+    profile?: CutterExportProfile;
+    encoder?: CutterExportEncoder;
+    audioStreamIndex?: number;
 }
 
 interface ReleaseUpdateInfo {
@@ -735,6 +756,7 @@ let currentCutterProcess: ChildProcess | null = null;
 let currentCutterPartialFile: string | null = null;
 let cutterExportActive = false;
 let cutterExportCancelled = false;
+let cutterHardwareEncoderProbe: Promise<CutterHardwareEncoder[]> | null = null;
 let cutterPreparedInput: { path: string; size: number; mtimeMs: number; dev: number; ino: number } | null = null;
 let cutterMediaGeneration = 0;
 let cutterMediaRequestGeneration = 0;
@@ -2629,7 +2651,7 @@ async function getVodStoryboard(vodId: string): Promise<VodStoryboard | null> {
             return null;
         }
 
-        let manifest: StoryboardManifestEntry[] | null = null;
+        let manifest: StoryboardManifestEntry[];
         try {
             const manifestResp = await axios.get<StoryboardManifestEntry[]>(manifestUrl, {
                 timeout: 6000,
@@ -2771,6 +2793,12 @@ function isSupportedVideoEditorInput(filePath: string): boolean {
     return ['.mp4', '.m4v', '.mov', '.webm', '.mkv', '.ts', '.avi'].includes(path.extname(filePath).toLowerCase());
 }
 
+function normalizeCutterRotation(value: unknown): 0 | 90 | 180 | 270 {
+    const numeric = Number(value);
+    const normalized = ((numeric % 360) + 360) % 360;
+    return normalized === 90 || normalized === 180 || normalized === 270 ? normalized : 0;
+}
+
 async function getVideoInfo(filePath: string, trackedProcesses?: Set<ChildProcess>, timeoutMs = 30000): Promise<VideoInfo | null> {
     const ffmpegReady = await ensureFfmpegInstalled();
     if (!ffmpegReady) {
@@ -2826,7 +2854,15 @@ async function getVideoInfo(filePath: string, trackedProcesses?: Set<ChildProces
             try {
                 const info = JSON.parse(output);
                 const videoStream = info.streams?.find((s: any) => s.codec_type === 'video');
-                const audioStream = info.streams?.find((s: any) => s.codec_type === 'audio');
+                const audioStreams = (Array.isArray(info.streams) ? info.streams : [])
+                    .filter((stream: any) => stream?.codec_type === 'audio')
+                    .map((stream: any, index: number) => ({
+                        index,
+                        codec: String(stream.codec_name || '').toLowerCase(),
+                        channels: Number.isFinite(stream.channels) ? Number(stream.channels) : 0,
+                        language: typeof stream.tags?.language === 'string' ? stream.tags.language : null,
+                    }));
+                const audioStream = audioStreams[0] ?? null;
                 const duration = parseFloat(info.format?.duration || videoStream?.duration || '0');
                 const averageFps = parseFrameRate(videoStream?.avg_frame_rate);
                 const realFps = parseFrameRate(videoStream?.r_frame_rate);
@@ -2838,8 +2874,11 @@ async function getVideoInfo(filePath: string, trackedProcesses?: Set<ChildProces
                 }
 
                 const videoCodec = String(videoStream.codec_name || '').toLowerCase();
-                const audioCodec = audioStream ? String(audioStream.codec_name || '').toLowerCase() : null;
+                const audioCodec = audioStream?.codec ?? null;
                 const variableFrameRate = averageFps > 0 && realFps > 0 && Math.abs(averageFps - realFps) / Math.max(averageFps, realFps) > 0.005;
+                const rotationData = Array.isArray(videoStream.side_data_list)
+                    ? videoStream.side_data_list.find((entry: any) => Number.isFinite(Number(entry?.rotation)))?.rotation
+                    : undefined;
                 finish({
                     duration,
                     width: videoStream.width,
@@ -2850,6 +2889,8 @@ async function getVideoInfo(filePath: string, trackedProcesses?: Set<ChildProces
                     audioCodec,
                     previewCompatible: isVideoEditorPreviewCompatible(filePath, videoCodec, audioCodec),
                     variableFrameRate,
+                    rotation: normalizeCutterRotation(rotationData ?? videoStream.tags?.rotate),
+                    audioStreams,
                 });
             } catch {
                 finish(null);
@@ -2860,6 +2901,40 @@ async function getVideoInfo(filePath: string, trackedProcesses?: Set<ChildProces
     });
 }
 
+async function getCutterHardwareEncoders(): Promise<CutterHardwareEncoder[]> {
+    if (cutterHardwareEncoderProbe) return await cutterHardwareEncoderProbe;
+    cutterHardwareEncoderProbe = (async (): Promise<CutterHardwareEncoder[]> => {
+        if (!await ensureFfmpegInstalled()) return [];
+        return await new Promise<CutterHardwareEncoder[]>((resolve) => {
+            const proc = spawn(getFFmpegPath(), ['-hide_banner', '-encoders'], { windowsHide: true });
+            currentCutterProbeProcesses.add(proc);
+            proc.stderr?.resume();
+            let output = '';
+            let settled = false;
+            const finish = (encoders: CutterHardwareEncoder[]): void => {
+                if (settled) return;
+                settled = true;
+                clearTimeout(timeout);
+                currentCutterProbeProcesses.delete(proc);
+                resolve(encoders);
+            };
+            const timeout = setTimeout(() => {
+                try { proc.kill(); } catch { }
+                finish([]);
+            }, 8000);
+            proc.stdout?.on('data', (chunk) => { output += chunk.toString(); });
+            proc.on('close', (code) => finish(code === 0 ? parseCutterHardwareEncoders(output) : []));
+            proc.on('error', () => finish([]));
+        });
+    })();
+    try {
+        return await cutterHardwareEncoderProbe;
+    } catch {
+        cutterHardwareEncoderProbe = null;
+        return [];
+    }
+}
+
 function cancelCutterMediaPreparation(): void {
     cutterAssetRunGeneration += 1;
     for (const process of currentCutterMediaProcesses) {
@@ -3100,6 +3175,66 @@ function getCutterInputIdentity(filePath: string): { path: string; size: number;
     }
 }
 
+function getCutterProjectSource(filePath: string): CutterProjectSource | null {
+    const identity = getCutterInputIdentity(filePath);
+    return identity ? { path: identity.path, size: identity.size, mtimeMs: identity.mtimeMs } : null;
+}
+
+function isCutterExportProfile(value: unknown): value is CutterExportProfile {
+    return value === 'quality' || value === 'balanced' || value === 'fast' || value === 'archive';
+}
+
+function isCutterExportEncoder(value: unknown): value is CutterExportEncoder {
+    return value === 'software' || value === 'h264_nvenc' || value === 'h264_qsv' || value === 'h264_amf';
+}
+
+function createCutterProject(filePath: string, info: VideoInfo, value: unknown): CutterProject | null {
+    if (!value || typeof value !== 'object') return null;
+    const project = value as Record<string, unknown>;
+    const profile = project.profile;
+    const encoder = project.encoder;
+    const audioStreamIndex = project.audioStreamIndex;
+    const trimStart = project.trimStart;
+    const trimEnd = project.trimEnd;
+    const cuts = project.cuts;
+    const source = getCutterProjectSource(filePath);
+    if (!source
+        || !isCutterExportProfile(profile)
+        || !isCutterExportEncoder(encoder)
+        || typeof audioStreamIndex !== 'number' || !Number.isInteger(audioStreamIndex) || audioStreamIndex < 0
+        || typeof trimStart !== 'number' || !Number.isFinite(trimStart)
+        || typeof trimEnd !== 'number' || !Number.isFinite(trimEnd)
+        || !Array.isArray(cuts) || cuts.length > 64
+        || cuts.some((cut) => !isPlainObject(cut)
+            || typeof cut.id !== 'string'
+            || typeof cut.start !== 'number' || !Number.isFinite(cut.start)
+            || typeof cut.end !== 'number' || !Number.isFinite(cut.end))) {
+        return null;
+    }
+    const hasSelectedAudio = info.audioStreams.some((stream) => stream.index === audioStreamIndex);
+    if ((info.hasAudio && !hasSelectedAudio) || (!info.hasAudio && audioStreamIndex !== 0)) return null;
+    let state = setTrimRange(createVideoEditorState(info.duration, info.fps), trimStart, trimEnd);
+    if (Math.abs(state.trimStart - trimStart) > 1 / info.fps || Math.abs(state.trimEnd - trimEnd) > 1 / info.fps) return null;
+    try {
+        for (const cut of cuts) {
+            state = addCutAt(state, cut.start, cut.end - cut.start).state;
+        }
+    } catch {
+        return null;
+    }
+    return {
+        source,
+        duration: info.duration,
+        fps: info.fps,
+        trimStart: state.trimStart,
+        trimEnd: state.trimEnd,
+        cuts: state.cuts.map((cut) => ({ ...cut })),
+        profile,
+        encoder,
+        audioStreamIndex,
+    };
+}
+
 function cutterInputIdentityMatches(filePath: string): boolean {
     const current = getCutterInputIdentity(filePath);
     return cutterInputIdentitiesMatch(current, cutterPreparedInput);
@@ -3160,13 +3295,18 @@ async function performVideoEditExport(request: VideoEditExportRequest, onProgres
     if (appShutdownStarted) return false;
     if (!request || typeof request.inputFile !== 'string' || typeof request.outputFile !== 'string') return false;
     if (!path.isAbsolute(request.inputFile) || !path.isAbsolute(request.outputFile) || !fs.existsSync(request.inputFile)) return false;
-    if (path.extname(request.outputFile).toLowerCase() !== '.mp4' || pathsReferToSameFile(request.inputFile, request.outputFile)) return false;
+    if (!isCutterExportProfile(request.profile) || !isCutterExportEncoder(request.encoder)) return false;
+    const profile = getCutterExportProfile(request.profile);
+    const outputExtension = `.${profile.container}`;
+    if (path.extname(request.outputFile).toLowerCase() !== outputExtension || pathsReferToSameFile(request.inputFile, request.outputFile)) return false;
     if (!Number.isFinite(request.trimStart) || !Number.isFinite(request.trimEnd) || !Array.isArray(request.cuts) || request.cuts.length > 64) return false;
     if (request.cuts.some((cut) => !isPlainObject(cut) || typeof cut.id !== 'string' || !Number.isFinite(cut.start) || !Number.isFinite(cut.end))) return false;
     const inputIdentity = getCutterInputIdentity(request.inputFile);
     if (!cutterInputIdentitiesMatch(inputIdentity, cutterPreparedInput)) return false;
     const info = await getVideoInfo(request.inputFile, currentCutterExportProcesses);
     if (!info || cutterExportCancelled) return false;
+    if (!Number.isInteger(request.audioStreamIndex) || request.audioStreamIndex < 0) return false;
+    if ((info.hasAudio && !info.audioStreams.some((stream) => stream.index === request.audioStreamIndex)) || (!info.hasAudio && request.audioStreamIndex !== 0)) return false;
     let state = setTrimRange(createVideoEditorState(info.duration, info.fps), request.trimStart, request.trimEnd);
     if (Math.abs(state.trimStart - request.trimStart) > 1 / info.fps || Math.abs(state.trimEnd - request.trimEnd) > 1 / info.fps) return false;
     try {
@@ -3183,12 +3323,23 @@ async function performVideoEditExport(request: VideoEditExportRequest, onProgres
     const inputBytes = fs.statSync(request.inputFile).size;
     const diskCheck = ensureDiskSpace(outputDir, Math.max(128 * 1024 * 1024, Math.ceil(inputBytes * 1.25)), 'Video-Editor');
     if (!diskCheck.success) return false;
-    const partialFile = path.join(outputDir, `.${path.basename(request.outputFile, '.mp4')}.${process.pid}.${Date.now()}.tvm-edit.mp4`);
+    const partialFile = path.join(outputDir, `.${path.basename(request.outputFile, outputExtension)}.${process.pid}.${Date.now()}.tvm-edit${outputExtension}`);
-    const plan = createCutterExportPlan({ inputFile: request.inputFile, outputFile: partialFile, segments, hasAudio: info.hasAudio });
+    const availableHardwareEncoders = request.encoder === 'software' ? [] : await getCutterHardwareEncoders();
+    let plan = createCutterExportPlan({
+        inputFile: request.inputFile,
+        outputFile: partialFile,
+        segments,
+        hasAudio: info.hasAudio,
+        profile: request.profile,
+        encoder: request.encoder,
+        availableHardwareEncoders,
+        audioStreamIndex: request.audioStreamIndex,
+        rotation: info.rotation,
+    });
     if (plan.filterComplex.length > 24000 || cutterExportCancelled) return false;
     currentCutterPartialFile = partialFile;
-    const success = await new Promise<boolean>((resolve) => {
+    const runPlan = async (activePlan: ReturnType<typeof createCutterExportPlan>): Promise<boolean> => await new Promise<boolean>((resolve) => {
-        const proc = spawn(getFFmpegPath(), plan.ffmpegArgs, { windowsHide: true });
+        const proc = spawn(getFFmpegPath(), activePlan.ffmpegArgs, { windowsHide: true });
         currentCutterProcess = proc;
         currentCutterExportProcesses.add(proc);
         proc.stderr?.resume();
@@ -3199,7 +3350,7 @@ async function performVideoEditExport(request: VideoEditExportRequest, onProgres
             stdout = lines.pop() || '';
             for (const line of lines) {
                 const match = line.match(/^out_time_(?:us|ms)=(\d+)$/);
-                if (match) onProgress(calculateCutterExportProgress(Number(match[1]) / 1_000_000, plan));
+                if (match) onProgress(calculateCutterExportProgress(Number(match[1]) / 1_000_000, activePlan));
             }
         });
         proc.on('close', (code) => {
@@ -3213,6 +3364,21 @@ async function performVideoEditExport(request: VideoEditExportRequest, onProgres
             resolve(false);
         });
     });
+    let success = await runPlan(plan);
+    if (!success && !cutterExportCancelled && plan.selectedEncoder !== 'libx264' && plan.selectedEncoder !== 'ffv1') {
+        try { fs.rmSync(partialFile, { force: true }); } catch { }
+        plan = createCutterExportPlan({
+            inputFile: request.inputFile,
+            outputFile: partialFile,
+            segments,
+            hasAudio: info.hasAudio,
+            profile: request.profile,
+            encoder: 'software',
+            audioStreamIndex: request.audioStreamIndex,
+            rotation: info.rotation,
+        });
+        success = await runPlan(plan);
+    }
     if (!success || !fs.existsSync(partialFile) || fs.statSync(partialFile).size <= 256) {
         fs.rmSync(partialFile, { force: true });
         currentCutterPartialFile = null;
@@ -5733,7 +5899,7 @@ async function downloadLiveStream(
     const outputs: string[] = [];
     let partNumber = 1;
     let resumeCount = 0;
-    let lastPartResult: DownloadResult = { success: false, error: tBackend('unknownDownloadError') };
+    let failedPartResult: DownloadResult | null = null;
 
     try {
         // Resume loop. Each iteration runs streamlink once. On clean exit,
@@ -5760,7 +5926,7 @@ async function downloadLiveStream(
             const partStartedAt = Date.now();
             appendDebugLog('recording-part-start', { itemId: item.id, partNumber, filename: path.basename(partFilename) });
 
-            lastPartResult = await downloadVODPart(item.url, partFilename, null, null, wrappedProgress, item.id, partNumber, partNumber);
+            const partResult = await downloadVODPart(item.url, partFilename, null, null, wrappedProgress, item.id, partNumber, partNumber);
 
             // Accumulate this part's final bytes into the running total so
             // the next part's meta line continues from the correct figure.
@@ -5774,6 +5940,7 @@ async function downloadLiveStream(
                 outputs.push(partFilename);
                 accumulatedBytes += partFinalBytes;
             } else {
+                failedPartResult = partResult;
                 // Streamlink produced no bytes — likely permission or auth
                 // failure. Skip resume because retrying will hit the same
                 // wall. The error from lastPartResult will surface upstream.
@@ -5842,7 +6009,7 @@ async function downloadLiveStream(
         stopLiveEventsTracker(item.id, {
             success: outputs.length > 0,
             durationMs: Date.now() - recordingStartedAt,
-            error: outputs.length === 0 ? lastPartResult.error : undefined
+            error: outputs.length === 0 ? failedPartResult?.error ?? tBackend('unknownDownloadError') : undefined
         });
     }
 
@@ -5864,7 +6031,7 @@ async function downloadLiveStream(
         });
     }
 
-    if (outputs.length === 0) return lastPartResult;
+    if (outputs.length === 0) return failedPartResult ?? { success: false, error: tBackend('unknownDownloadError') };
 
     // Auto-merge resumed parts. Only attempt when (a) the user opted in,
     // (b) there's actually something to merge, and (c) the parts are all
@@ -8298,33 +8465,86 @@ ipcMain.handle('cancel-video-editor-assets', (event, jobId: number) => {
     return true;
 });
 
+ipcMain.handle('get-cutter-project-recovery', (event, capability: string) => {
+    if (!isTrustedRendererEvent(event) || appShutdownStarted) return null;
+    const filePath = resolveFileCapability(event, capability, 'cutter-input');
+    const source = filePath ? getCutterProjectSource(filePath) : null;
+    return source ? cutterProjectAutosaves.find(source) : null;
+});
+
+ipcMain.handle('save-cutter-project', async (event, capability: string, value: unknown) => {
+    if (!isTrustedRendererEvent(event) || appShutdownStarted) return false;
+    const filePath = resolveFileCapability(event, capability, 'cutter-input');
+    if (!filePath || !cutterInputIdentityMatches(filePath) || !cutterMediaJob || !cutterInputIdentitiesMatch(getCutterInputIdentity(filePath), cutterMediaJob.identity)) return false;
+    const project = createCutterProject(filePath, cutterMediaJob.info, value);
+    if (!project) return false;
+    try {
+        cutterProjectAutosaves.save(project);
+        return true;
+    } catch (error) {
+        appendDebugLog('cutter-project-save-failed', String(error));
+        return false;
+    }
+});
+
+ipcMain.handle('discard-cutter-project', (event, capability: string) => {
+    if (!isTrustedRendererEvent(event) || appShutdownStarted) return false;
+    const filePath = resolveFileCapability(event, capability, 'cutter-input');
+    const source = filePath ? getCutterProjectSource(filePath) : null;
+    if (!source) return false;
+    try {
+        return cutterProjectAutosaves.discard(source);
+    } catch (error) {
+        appendDebugLog('cutter-project-discard-failed', String(error));
+        return false;
+    }
+});
+
+ipcMain.handle('open-cutter-project', (event, capability: string) => {
+    if (!isTrustedRendererEvent(event) || appShutdownStarted) return null;
+    const filePath = resolveFileCapability(event, capability, 'cutter-input');
+    const source = filePath ? getCutterProjectSource(filePath) : null;
+    return source ? cutterProjectAutosaves.find(source) : null;
+});
+
+ipcMain.handle('get-cutter-export-options', async (event) => {
+    if (!isTrustedRendererEvent(event) || appShutdownStarted) return null;
+    return { profiles: CUTTER_EXPORT_PROFILES, hardwareEncoders: await getCutterHardwareEncoders() };
+});
+
 ipcMain.handle('export-video-edit', async (event, request: RendererVideoEditExportRequest) => {
     if (!isTrustedRendererEvent(event) || appShutdownStarted || !request || typeof request.inputCapability !== 'string') return { success: false, outputName: null };
     const inputFile = resolveFileCapability(event, request.inputCapability, 'cutter-input');
     if (!inputFile || !cutterInputIdentityMatches(inputFile)) return { success: false, outputName: null };
+    const profile = request.profile ?? 'balanced';
+    const encoder = request.encoder ?? 'software';
+    const audioStreamIndex = request.audioStreamIndex ?? 0;
+    if (!isCutterExportProfile(profile) || !isCutterExportEncoder(encoder) || !Number.isInteger(audioStreamIndex) || audioStreamIndex < 0) return { success: false, outputName: null };
+    const profileDefinition = getCutterExportProfile(profile);
+    const extension = profileDefinition.container;
     let outputFile: string | null = null;
     const testRoot = process.env.TWITCH_VOD_MANAGER_E2E_CUTTER_OUTPUT_ROOT;
     if (testRoot && typeof request.outputName === 'string' && path.basename(request.outputName) === request.outputName) {
         const candidate = path.join(testRoot, request.outputName);
         if (isPathInsideDirectory(testRoot, candidate)) {
-            const outputCapability = issueFileCapability(event, 'cutter-output', candidate, 'output-file', ['mp4']);
+            const outputCapability = issueFileCapability(event, 'cutter-output', candidate, 'output-file', [extension]);
             outputFile = resolveFileCapability(event, outputCapability.token, 'cutter-output', true, [inputFile]);
         }
     } else {
-        const defaultName = path.join(path.dirname(inputFile), `${path.basename(inputFile, path.extname(inputFile))}_edited.mp4`);
+        const defaultName = path.join(path.dirname(inputFile), `${path.basename(inputFile, path.extname(inputFile))}_edited.${extension}`);
         const result = await dialog.showSaveDialog(mainWindow!, {
             defaultPath: defaultName,
-            filters: [{ name: 'MP4 Video', extensions: ['mp4'] }],
+            filters: [{ name: `${profileDefinition.label} Video`, extensions: [extension] }],
         });
         if (result.canceled || !result.filePath) return { success: false, outputName: null, cancelled: true };
-        const outputCapability = issueFileCapability(event, 'cutter-output', result.filePath, 'output-file', ['mp4']);
+        const outputCapability = issueFileCapability(event, 'cutter-output', result.filePath, 'output-file', [extension]);
         outputFile = resolveFileCapability(event, outputCapability.token, 'cutter-output', true, [inputFile]);
     }
     if (!outputFile) return { success: false, outputName: null };
-    const outcome = await exportVideoEdit({ inputFile, outputFile, trimStart: request.trimStart, trimEnd: request.trimEnd, cuts: request.cuts }, (percent) => {
+    const outcome = await exportVideoEdit({ inputFile, outputFile, trimStart: request.trimStart, trimEnd: request.trimEnd, cuts: request.cuts, profile, encoder, audioStreamIndex }, (percent) => {
         mainWindow?.webContents.send('cut-progress', percent);
     });
-    const outputCapability = outcome.success ? issueFileCapability(event, 'show-in-folder', outputFile, 'input-file', ['mp4']) : null;
+    const outputCapability = outcome.success ? issueFileCapability(event, 'show-in-folder', outputFile, 'input-file', [extension]) : null;
     return { success: outcome.success, outputCapability: outputCapability?.token, outputName: outcome.success ? path.basename(outputFile) : null, cancelled: outcome.cancelled || undefined };
 });
 
@@ -8440,8 +8660,6 @@ app.whenReady().then(() => {
     startDebugLogFlushTimer();
 
     try {
-        const { openDatabase } = require('./main/infra/db');
-        const { migrateJsonToSqlite } = require('./main/domain/migrator');
         const dbPath = path.join(APPDATA_DIR, 'app.db');
         const database: DbHandle = openDatabase(dbPath);
         appDb = database;

src/main/domain/cutter-export.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { calculateCutterExportProgress, createCutterExportPlan } from './cutter-export';
+import { calculateCutterExportProgress, createCutterExportPlan, parseCutterHardwareEncoders } from './cutter-export';
 
 describe('cutter export segments', () => {
     test('sorts playable segments and preserves the caller input', () => {
@@ -113,4 +113,65 @@ describe('cutter export segments', () => {
         expect(calculateCutterExportProgress(45, plan)).toBe(100);
         expect(calculateCutterExportProgress(-5, plan)).toBe(0);
     });
+
+    test('builds a rotated quality MP4 profile for an explicitly selected audio stream', () => {
+        const plan = createCutterExportPlan({
+            inputFile: 'input.mov',
+            outputFile: 'output.mp4',
+            segments: [{ start: 0, end: 20 }],
+            hasAudio: true,
+            profile: 'quality',
+            encoder: 'software',
+            audioStreamIndex: 1,
+            rotation: 90,
+        });
+
+        expect(plan.filterComplex).toContain('[0:v]trim=start=0:end=20,setpts=PTS-STARTPTS,transpose=1[v0]');
+        expect(plan.filterComplex).toContain('[0:a:1]atrim=start=0:end=20,asetpts=PTS-STARTPTS[a0]');
+        expect(plan.ffmpegArgs).toContain('-noautorotate');
+        expect(plan.ffmpegArgs).toEqual(expect.arrayContaining(['-c:v', 'libx264', '-preset', 'slow', '-crf', '18', '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-b:a', '192k']));
+    });
+
+    test('falls back to a compatible software encoder when the requested hardware encoder is absent', () => {
+        const plan = createCutterExportPlan({
+            inputFile: 'input.mp4',
+            outputFile: 'output.mp4',
+            segments: [{ start: 0, end: 20 }],
+            hasAudio: true,
+            profile: 'fast',
+            encoder: 'h264_nvenc',
+            availableHardwareEncoders: [],
+        });
+
+        expect(plan.selectedEncoder).toBe('libx264');
+        expect(plan.hardwareFallback).toBe(true);
+        expect(plan.ffmpegArgs).toEqual(expect.arrayContaining(['-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '23']));
+    });
+
+    test('requires the lossless archive profile to use its compatible MKV container', () => {
+        expect(() => createCutterExportPlan({
+            inputFile: 'input.mp4',
+            outputFile: 'archive.mp4',
+            segments: [{ start: 0, end: 20 }],
+            hasAudio: true,
+            profile: 'archive',
+            encoder: 'software',
+        })).toThrow('MKV');
+
+        const plan = createCutterExportPlan({
+            inputFile: 'input.mp4',
+            outputFile: 'archive.mkv',
+            segments: [{ start: 0, end: 20 }],
+            hasAudio: true,
+            profile: 'archive',
+            encoder: 'software',
+        });
+
+        expect(plan.ffmpegArgs).toEqual(expect.arrayContaining(['-c:v', 'ffv1', '-c:a', 'flac', '-pix_fmt', 'yuv420p']));
+        expect(plan.ffmpegArgs).not.toContain('+faststart');
+    });
+
+    test('recognizes only offered H.264 hardware encoders from an ffmpeg probe', () => {
+        expect(parseCutterHardwareEncoders(' V..... h264_nvenc NVIDIA NVENC H.264 encoder\n V..... h264_qsv H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (Intel Quick Sync Video acceleration)\n V..... hevc_amf AMD AMF HEVC encoder')).toEqual(['h264_nvenc', 'h264_qsv']);
+    });
 });

src/main/domain/cutter-export.ts

@@ -1,10 +1,33 @@
+import * as path from 'node:path';
 import type { EditorSegment } from './video-editor';
 
+export type CutterExportProfile = 'quality' | 'balanced' | 'fast' | 'archive';
+export type CutterHardwareEncoder = 'h264_nvenc' | 'h264_qsv' | 'h264_amf';
+export type CutterExportEncoder = 'software' | CutterHardwareEncoder;
+
+export interface CutterExportProfileDefinition {
+    id: CutterExportProfile;
+    label: string;
+    container: 'mp4' | 'mkv';
+}
+
+export const CUTTER_EXPORT_PROFILES: CutterExportProfileDefinition[] = [
+    { id: 'quality', label: 'Quality', container: 'mp4' },
+    { id: 'balanced', label: 'Balanced', container: 'mp4' },
+    { id: 'fast', label: 'Fast', container: 'mp4' },
+    { id: 'archive', label: 'Archive', container: 'mkv' },
+];
+
 export interface CutterExportPlanOptions {
     inputFile: string;
     outputFile: string;
     segments: readonly EditorSegment[];
     hasAudio: boolean;
+    profile?: CutterExportProfile;
+    encoder?: CutterExportEncoder;
+    availableHardwareEncoders?: readonly CutterHardwareEncoder[];
+    audioStreamIndex?: number;
+    rotation?: number;
 }
 
 export interface CutterExportPlan {
@@ -12,9 +35,13 @@ export interface CutterExportPlan {
     remainingDuration: number;
     filterComplex: string;
     ffmpegArgs: string[];
+    profile: CutterExportProfile;
+    selectedEncoder: 'libx264' | 'ffv1' | CutterHardwareEncoder;
+    hardwareFallback: boolean;
 }
 
 const precision = 9;
+const hardwareEncoders: CutterHardwareEncoder[] = ['h264_nvenc', 'h264_qsv', 'h264_amf'];
 
 function round(value: number): number {
     return Number(value.toFixed(precision));
@@ -53,17 +80,46 @@ function normalizeSegments(segments: readonly EditorSegment[]): EditorSegment[]
     return normalized;
 }
 
-function createFilterComplex(segments: readonly EditorSegment[], hasAudio: boolean): string {
+function getProfileDefinition(profile: CutterExportProfile): CutterExportProfileDefinition {
+    const definition = CUTTER_EXPORT_PROFILES.find((entry) => entry.id === profile);
+    if (!definition) throw new Error('Unsupported cutter export profile');
+    return definition;
+}
+
+function normalizeRotation(rotation: number | undefined): 0 | 90 | 180 | 270 {
+    const normalized = ((rotation ?? 0) % 360 + 360) % 360;
+    if (normalized === 0 || normalized === 90 || normalized === 180 || normalized === 270) return normalized;
+    throw new Error('Rotation must be 0, 90, 180, or 270 degrees');
+}
+
+function normalizeAudioStreamIndex(value: number | undefined): number {
+    const index = value ?? 0;
+    if (!Number.isInteger(index) || index < 0) throw new Error('audioStreamIndex must be a non-negative integer');
+    return index;
+}
+
+function videoRotationFilter(rotation: 0 | 90 | 180 | 270): string | null {
+    if (rotation === 90) return 'transpose=1';
+    if (rotation === 180) return 'hflip,vflip';
+    if (rotation === 270) return 'transpose=2';
+    return null;
+}
+
+function createFilterComplex(segments: readonly EditorSegment[], hasAudio: boolean, audioStreamIndex: number, rotation: 0 | 90 | 180 | 270): string {
     const filters: string[] = [];
     const concatInputs: string[] = [];
+    const rotationFilter = videoRotationFilter(rotation);
+    const audioInput = audioStreamIndex === 0 ? '[0:a]' : `[0:a:${audioStreamIndex}]`;
 
     segments.forEach((segment, index) => {
         const start = formatSeconds(segment.start);
         const end = formatSeconds(segment.end);
-        filters.push(`[0:v]trim=start=${start}:end=${end},setpts=PTS-STARTPTS[v${index}]`);
+        const videoFilters = [`trim=start=${start}:end=${end}`, 'setpts=PTS-STARTPTS'];
+        if (rotationFilter) videoFilters.push(rotationFilter);
+        filters.push(`[0:v]${videoFilters.join(',')}[v${index}]`);
         concatInputs.push(`[v${index}]`);
         if (hasAudio) {
-            filters.push(`[0:a]atrim=start=${start}:end=${end},asetpts=PTS-STARTPTS[a${index}]`);
+            filters.push(`${audioInput}atrim=start=${start}:end=${end},asetpts=PTS-STARTPTS[a${index}]`);
             concatInputs.push(`[a${index}]`);
         }
     });
@@ -72,31 +128,89 @@ function createFilterComplex(segments: readonly EditorSegment[], hasAudio: boole
     return filters.join(';');
 }
 
-function createFfmpegArgs(inputFile: string, outputFile: string, filterComplex: string, hasAudio: boolean): string[] {
+function resolveEncoder(profile: CutterExportProfile, requested: CutterExportEncoder, availableHardwareEncoders: readonly CutterHardwareEncoder[]): { selectedEncoder: CutterExportPlan['selectedEncoder']; hardwareFallback: boolean } {
-    const args = [
+    if (profile === 'archive') {
-        '-i', inputFile,
+        return { selectedEncoder: 'ffv1', hardwareFallback: requested !== 'software' };
-        '-filter_complex', filterComplex,
+    }
-        '-map', '[outv]',
+    if (requested === 'software') {
-    ];
+        return { selectedEncoder: 'libx264', hardwareFallback: false };
+    }
+    if (hardwareEncoders.includes(requested) && availableHardwareEncoders.includes(requested)) {
+        return { selectedEncoder: requested, hardwareFallback: false };
+    }
+    return { selectedEncoder: 'libx264', hardwareFallback: true };
+}
+
+function softwareVideoArgs(profile: CutterExportProfile): string[] {
+    if (profile === 'quality') return ['-c:v', 'libx264', '-preset', 'slow', '-crf', '18'];
+    if (profile === 'fast') return ['-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '23'];
+    return ['-c:v', 'libx264', '-preset', 'veryfast', '-crf', '20'];
+}
+
+function hardwareVideoArgs(profile: Exclude<CutterExportProfile, 'archive'>, encoder: CutterHardwareEncoder): string[] {
+    const quality = profile === 'quality' ? '18' : profile === 'balanced' ? '20' : '23';
+    if (encoder === 'h264_nvenc') {
+        return ['-c:v', encoder, '-preset', profile === 'quality' ? 'p6' : profile === 'balanced' ? 'p4' : 'p1', '-cq', quality, '-b:v', '0'];
+    }
+    if (encoder === 'h264_qsv') {
+        return ['-c:v', encoder, '-preset', profile === 'quality' ? 'slow' : profile === 'balanced' ? 'medium' : 'veryfast', '-global_quality', quality];
+    }
+    return ['-c:v', encoder, '-quality', profile === 'quality' ? 'quality' : profile === 'balanced' ? 'balanced' : 'speed', '-rc', 'cqp', '-qp_i', quality, '-qp_p', quality];
+}
+
+function audioArgs(profile: CutterExportProfile, hasAudio: boolean): string[] {
+    if (!hasAudio) return ['-an'];
+    if (profile === 'archive') return ['-c:a', 'flac'];
+    const bitrate = profile === 'quality' ? '192k' : profile === 'balanced' ? '160k' : '128k';
+    return ['-c:a', 'aac', '-b:a', bitrate];
+}
+
+function createFfmpegArgs(inputFile: string, outputFile: string, filterComplex: string, hasAudio: boolean, profile: CutterExportProfile, selectedEncoder: CutterExportPlan['selectedEncoder'], rotation: 0 | 90 | 180 | 270): string[] {
+    const args: string[] = [];
+    if (rotation !== 0) args.push('-noautorotate');
+    args.push('-i', inputFile, '-filter_complex', filterComplex, '-map', '[outv]');
     if (hasAudio) args.push('-map', '[outa]');
-    args.push('-c:v', 'libx264', '-preset', 'veryfast', '-crf', '20', '-pix_fmt', 'yuv420p');
+    if (selectedEncoder === 'ffv1') args.push('-c:v', 'ffv1', '-level', '3', '-g', '1');
-    if (hasAudio) args.push('-c:a', 'aac', '-b:a', '160k');
+    else if (selectedEncoder === 'libx264') args.push(...softwareVideoArgs(profile));
-    else args.push('-an');
+    else args.push(...hardwareVideoArgs(profile as Exclude<CutterExportProfile, 'archive'>, selectedEncoder));
-    args.push('-movflags', '+faststart', '-progress', 'pipe:1', '-y', outputFile);
+    args.push('-pix_fmt', 'yuv420p', ...audioArgs(profile, hasAudio));
+    if (profile !== 'archive') args.push('-movflags', '+faststart');
+    args.push('-progress', 'pipe:1', '-y', outputFile);
     return args;
 }
 
+export function parseCutterHardwareEncoders(ffmpegEncodersOutput: string): CutterHardwareEncoder[] {
+    return hardwareEncoders.filter((encoder) => new RegExp(`\\b${encoder}\\b`, 'i').test(ffmpegEncodersOutput));
+}
+
+export function getCutterExportProfile(profile: CutterExportProfile): CutterExportProfileDefinition {
+    return getProfileDefinition(profile);
+}
+
 export function createCutterExportPlan(options: CutterExportPlanOptions): CutterExportPlan {
     const inputFile = validatePath(options.inputFile, 'inputFile');
     const outputFile = validatePath(options.outputFile, 'outputFile');
+    const profile = options.profile ?? 'balanced';
+    const profileDefinition = getProfileDefinition(profile);
+    const expectedExtension = `.${profileDefinition.container}`;
+    if (path.extname(outputFile).toLowerCase() !== expectedExtension) {
+        throw new Error(`${profileDefinition.container.toUpperCase()} output is required for the ${profile} profile`);
+    }
     const segments = normalizeSegments(options.segments);
+    const audioStreamIndex = normalizeAudioStreamIndex(options.audioStreamIndex);
+    const rotation = normalizeRotation(options.rotation);
+    const requestedEncoder = options.encoder ?? 'software';
+    const encoder = resolveEncoder(profile, requestedEncoder, options.availableHardwareEncoders ?? []);
     const remainingDuration = round(segments.reduce((total, segment) => total + segment.end - segment.start, 0));
-    const filterComplex = createFilterComplex(segments, options.hasAudio);
+    const filterComplex = createFilterComplex(segments, options.hasAudio, audioStreamIndex, rotation);
     return {
         segments,
         remainingDuration,
         filterComplex,
-        ffmpegArgs: createFfmpegArgs(inputFile, outputFile, filterComplex, options.hasAudio),
+        ffmpegArgs: createFfmpegArgs(inputFile, outputFile, filterComplex, options.hasAudio, profile, encoder.selectedEncoder, rotation),
+        profile,
+        selectedEncoder: encoder.selectedEncoder,
+        hardwareFallback: encoder.hardwareFallback,
     };
 }
 

src/main/domain/cutter-project.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createCutterProjectAutosaveStore } from './cutter-project';
+
+let directory: string;
+
+beforeEach(() => {
+    directory = fs.mkdtempSync(path.join(os.tmpdir(), 'twitch-vod-manager-cutter-project-'));
+});
+
+afterEach(() => {
+    fs.rmSync(directory, { recursive: true, force: true });
+});
+
+describe('cutter project autosave', () => {
+    test('restores a crash-saved edit after recreating the local store', () => {
+        const autosavePath = path.join(directory, 'cutter-projects.json');
+        const source = { path: 'C:\\Media\\source.mp4', size: 2_048_000, mtimeMs: 1_725_000_000_000 };
+        const savingStore = createCutterProjectAutosaveStore(autosavePath);
+
+        savingStore.save({
+            source,
+            duration: 120,
+            fps: 30,
+            trimStart: 5,
+            trimEnd: 110,
+            cuts: [{ id: 'cut-1', start: 32, end: 46 }],
+            profile: 'quality',
+            encoder: 'software',
+            audioStreamIndex: 1,
+        });
+
+        const recovered = createCutterProjectAutosaveStore(autosavePath).find(source);
+
+        expect(recovered).toMatchObject({
+            source,
+            trimStart: 5,
+            trimEnd: 110,
+            cuts: [{ id: 'cut-1', start: 32, end: 46 }],
+            profile: 'quality',
+            audioStreamIndex: 1,
+        });
+        expect(fs.existsSync(`${autosavePath}.tmp`)).toBe(false);
+    });
+
+    test.each([
+        ['path', (source: { path: string; size: number; mtimeMs: number }) => ({ ...source, path: 'C:\\Media\\renamed.mp4' })],
+        ['size', (source: { path: string; size: number; mtimeMs: number }) => ({ ...source, size: source.size + 1 })],
+        ['modification time', (source: { path: string; size: number; mtimeMs: number }) => ({ ...source, mtimeMs: source.mtimeMs + 1 })],
+    ])('rejects a recovery when the source %s changed', (_field, mutate) => {
+        const autosavePath = path.join(directory, 'cutter-projects.json');
+        const savedSource = { path: 'C:\\Media\\source.mp4', size: 2_048_000, mtimeMs: 1_725_000_000_000 };
+        const changedSource = mutate(savedSource);
+        const store = createCutterProjectAutosaveStore(autosavePath);
+        store.save({
+            source: savedSource,
+            duration: 120,
+            fps: 30,
+            trimStart: 0,
+            trimEnd: 120,
+            cuts: [],
+            profile: 'balanced',
+            encoder: 'software',
+            audioStreamIndex: 0,
+        });
+
+        expect(store.find(changedSource)).toBeNull();
+    });
+
+    test('discards the current source recovery', () => {
+        const autosavePath = path.join(directory, 'cutter-projects.json');
+        const savedSource = { path: 'C:\\Media\\source.mp4', size: 2_048_000, mtimeMs: 1_725_000_000_000 };
+        const store = createCutterProjectAutosaveStore(autosavePath);
+        store.save({
+            source: savedSource,
+            duration: 120,
+            fps: 30,
+            trimStart: 0,
+            trimEnd: 120,
+            cuts: [],
+            profile: 'balanced',
+            encoder: 'software',
+            audioStreamIndex: 0,
+        });
+
+        expect(store.discard(savedSource)).toBe(true);
+        expect(createCutterProjectAutosaveStore(autosavePath).find(savedSource)).toBeNull();
+    });
+});

src/main/domain/cutter-project.ts

@@ -0,0 +1,126 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { writeFileAtomicSync } from '../infra/fs-atomic';
+import type { CutterExportEncoder, CutterExportProfile } from './cutter-export';
+
+export interface CutterProjectSource {
+    path: string;
+    size: number;
+    mtimeMs: number;
+}
+
+export interface CutterProject {
+    source: CutterProjectSource;
+    duration: number;
+    fps: number;
+    trimStart: number;
+    trimEnd: number;
+    cuts: Array<{ id: string; start: number; end: number }>;
+    profile: CutterExportProfile;
+    encoder: CutterExportEncoder;
+    audioStreamIndex: number;
+}
+
+interface CutterProjectDocument {
+    version: 1;
+    projects: CutterProject[];
+}
+
+function cloneProject(project: CutterProject): CutterProject {
+    return {
+        ...project,
+        source: { ...project.source },
+        cuts: project.cuts.map((cut) => ({ ...cut })),
+    };
+}
+
+function sourceKey(source: CutterProjectSource): string {
+    return `${source.path}\u0000${source.size}\u0000${source.mtimeMs}`;
+}
+
+function isProjectSource(value: unknown): value is CutterProjectSource {
+    if (!value || typeof value !== 'object') return false;
+    const source = value as Record<string, unknown>;
+    return typeof source.path === 'string'
+        && source.path.length > 0
+        && typeof source.size === 'number'
+        && Number.isFinite(source.size)
+        && source.size >= 0
+        && typeof source.mtimeMs === 'number'
+        && Number.isFinite(source.mtimeMs)
+        && source.mtimeMs >= 0;
+}
+
+function isProject(value: unknown): value is CutterProject {
+    if (!value || typeof value !== 'object') return false;
+    const project = value as Record<string, unknown>;
+    return isProjectSource(project.source)
+        && typeof project.duration === 'number'
+        && Number.isFinite(project.duration)
+        && project.duration > 0
+        && typeof project.fps === 'number'
+        && Number.isFinite(project.fps)
+        && project.fps > 0
+        && typeof project.trimStart === 'number'
+        && Number.isFinite(project.trimStart)
+        && typeof project.trimEnd === 'number'
+        && Number.isFinite(project.trimEnd)
+        && Array.isArray(project.cuts)
+        && project.cuts.every((cut) => cut && typeof cut === 'object'
+            && typeof (cut as Record<string, unknown>).id === 'string'
+            && typeof (cut as Record<string, unknown>).start === 'number'
+            && Number.isFinite((cut as Record<string, unknown>).start)
+            && typeof (cut as Record<string, unknown>).end === 'number'
+            && Number.isFinite((cut as Record<string, unknown>).end))
+        && (project.profile === 'quality' || project.profile === 'balanced' || project.profile === 'fast' || project.profile === 'archive')
+        && (project.encoder === 'software' || project.encoder === 'h264_nvenc' || project.encoder === 'h264_qsv' || project.encoder === 'h264_amf')
+        && typeof project.audioStreamIndex === 'number'
+        && Number.isInteger(project.audioStreamIndex)
+        && project.audioStreamIndex >= 0;
+}
+
+function readDocument(filePath: string): CutterProjectDocument {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8')) as Record<string, unknown>;
+        if (parsed.version !== 1 || !Array.isArray(parsed.projects)) return { version: 1, projects: [] };
+        return { version: 1, projects: parsed.projects.filter(isProject).map(cloneProject) };
+    } catch {
+        return { version: 1, projects: [] };
+    }
+}
+
+export interface CutterProjectAutosaveStore {
+    find(source: CutterProjectSource): CutterProject | null;
+    save(project: CutterProject): void;
+    discard(source: CutterProjectSource): boolean;
+}
+
+export function createCutterProjectAutosaveStore(filePath: string): CutterProjectAutosaveStore {
+    const write = (document: CutterProjectDocument): void => {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        writeFileAtomicSync(filePath, JSON.stringify(document));
+    };
+
+    return {
+        find(source) {
+            const project = readDocument(filePath).projects.find((entry) => sourceKey(entry.source) === sourceKey(source));
+            return project ? cloneProject(project) : null;
+        },
+        save(project) {
+            if (!isProject(project)) throw new Error('Invalid cutter project');
+            const document = readDocument(filePath);
+            const key = sourceKey(project.source);
+            const projects = document.projects.filter((entry) => sourceKey(entry.source) !== key);
+            projects.push(cloneProject(project));
+            write({ version: 1, projects });
+        },
+        discard(source) {
+            const document = readDocument(filePath);
+            const key = sourceKey(source);
+            const projects = document.projects.filter((entry) => sourceKey(entry.source) !== key);
+            if (projects.length === document.projects.length) return false;
+            write({ version: 1, projects });
+            return true;
+        },
+    };
+}

src/preload.ts

@@ -193,6 +193,11 @@ contextBridge.exposeInMainWorld('api', {
     prepareVideoEditorWaveform: (capability: string, jobId: number): Promise<VideoEditorWaveform | null> => ipcRenderer.invoke('prepare-video-editor-waveform', capability, jobId),
     prepareVideoEditorAssets: (capability: string, jobId: number, profile: VideoEditorAssetProfile): Promise<VideoEditorAssets | null> => ipcRenderer.invoke('prepare-video-editor-assets', capability, jobId, profile),
     cancelVideoEditorAssets: (jobId: number): Promise<boolean> => ipcRenderer.invoke('cancel-video-editor-assets', jobId),
+    getCutterProjectRecovery: (capability: string): Promise<CutterProject | null> => ipcRenderer.invoke('get-cutter-project-recovery', capability),
+    saveCutterProject: (capability: string, project: Omit<CutterProject, 'source' | 'duration' | 'fps'>): Promise<boolean> => ipcRenderer.invoke('save-cutter-project', capability, project),
+    discardCutterProject: (capability: string): Promise<boolean> => ipcRenderer.invoke('discard-cutter-project', capability),
+    openCutterProject: (capability: string): Promise<CutterProject | null> => ipcRenderer.invoke('open-cutter-project', capability),
+    getCutterExportOptions: (): Promise<CutterExportOptions | null> => ipcRenderer.invoke('get-cutter-export-options'),
     exportVideoEdit: (request: VideoEditExportRequest): Promise<{ success: boolean; outputCapability?: string; outputName: string | null; cancelled?: boolean }> => ipcRenderer.invoke('export-video-edit', request),
     cancelVideoEdit: (): Promise<boolean> => ipcRenderer.invoke('cancel-video-edit'),
     cutVideo: (inputCapability: string, startTime: number, endTime: number): Promise<{ success: boolean; outputName: string | null }> =>

src/renderer-cutter.ts

@@ -61,6 +61,12 @@ let cutterScrubSeekInFlight = false;
 let cutterScrubResumePlayback = false;
 let cutterScrubGeneration = 0;
 let cutterDiscardResolver: ((discard: boolean) => void) | null = null;
+let cutterExportProfile: 'quality' | 'balanced' | 'fast' | 'archive' = 'balanced';
+let cutterExportEncoder: 'software' | 'h264_nvenc' | 'h264_qsv' | 'h264_amf' = 'software';
+let cutterAudioStreamIndex = 0;
+let cutterPendingProject: CutterProject | null = null;
+let cutterAutosaveTimer: number | null = null;
+let cutterExportOptions: CutterExportOptions | null = null;
 const cutterMaximumCuts = 64;
 const cutterFrameTolerance = 1e-8;
 
@@ -139,12 +145,194 @@ function getCutterPlayableDuration(): number {
     return Math.max(0, cutterEditorState.trimEnd - cutterEditorState.trimStart - removed);
 }
 
+function getCutterProjectPayload(): Omit<CutterProject, 'source' | 'duration' | 'fps'> | null {
+    if (!cutterEditorState) return null;
+    return {
+        trimStart: cutterEditorState.trimStart,
+        trimEnd: cutterEditorState.trimEnd,
+        cuts: cutterEditorState.cuts.map((cut) => ({ ...cut })),
+        profile: cutterExportProfile,
+        encoder: cutterExportEncoder,
+        audioStreamIndex: cutterAudioStreamIndex,
+    };
+}
+
+async function persistCutterProject(showResult: boolean): Promise<boolean> {
+    const file = cutterFile;
+    const project = getCutterProjectPayload();
+    if (!file || !project) return false;
+    let saved = false;
+    try {
+        saved = await window.api.saveCutterProject(file.token, project);
+    } catch { }
+    if (showResult) showAppToast(saved ? 'Projekt gespeichert' : 'Projekt konnte nicht gespeichert werden', saved ? 'info' : 'warn');
+    return saved;
+}
+
+function scheduleCutterAutosave(): void {
+    if (cutterAutosaveTimer !== null) window.clearTimeout(cutterAutosaveTimer);
+    const file = cutterFile;
+    cutterAutosaveTimer = window.setTimeout(() => {
+        cutterAutosaveTimer = null;
+        if (!file || cutterFile !== file) return;
+        void persistCutterProject(false);
+    }, 500);
+}
+
+function renderCutterProjectRecovery(project: CutterProject | null): void {
+    cutterPendingProject = project;
+    const panel = byId<HTMLElement>('cutterRecoveryPanel');
+    panel.hidden = !project;
+    if (project) byId('cutterRecoveryText').textContent = 'Gespeicherte Bearbeitung gefunden';
+}
+
+function updateCutterAudioStreams(): void {
+    const select = byId<HTMLSelectElement>('cutterAudioStream');
+    const streams = cutterVideoInfo?.audioStreams ?? [];
+    select.replaceChildren();
+    if (streams.length === 0) {
+        const option = document.createElement('option');
+        option.value = '0';
+        option.textContent = 'Keine Audiospur';
+        select.append(option);
+        select.disabled = true;
+        cutterAudioStreamIndex = 0;
+        return;
+    }
+    streams.forEach((stream) => {
+        const option = document.createElement('option');
+        option.value = String(stream.index);
+        const details = [stream.language, stream.codec, stream.channels > 0 ? `${stream.channels} Kanäle` : ''].filter(Boolean).join(' · ');
+        option.textContent = `Audiospur ${stream.index + 1}${details ? ` (${details})` : ''}`;
+        select.append(option);
+    });
+    if (!streams.some((stream) => stream.index === cutterAudioStreamIndex)) cutterAudioStreamIndex = streams[0].index;
+    select.value = String(cutterAudioStreamIndex);
+    select.disabled = false;
+}
+
+function updateCutterExportControls(options: CutterExportOptions | null): void {
+    const profile = byId<HTMLSelectElement>('cutterExportProfile');
+    const encoder = byId<HTMLSelectElement>('cutterExportEncoder');
+    if (options) {
+        profile.replaceChildren(...options.profiles.map((entry) => {
+            const option = document.createElement('option');
+            option.value = entry.id;
+            option.textContent = entry.label;
+            return option;
+        }));
+    }
+    profile.value = cutterExportProfile;
+    encoder.replaceChildren();
+    const software = document.createElement('option');
+    software.value = 'software';
+    software.textContent = 'Software';
+    encoder.append(software);
+    if (cutterExportProfile !== 'archive') {
+        (options?.hardwareEncoders ?? []).forEach((value) => {
+            const option = document.createElement('option');
+            option.value = value;
+            option.textContent = value === 'h264_nvenc' ? 'NVIDIA NVENC' : value === 'h264_qsv' ? 'Intel Quick Sync' : 'AMD AMF';
+            encoder.append(option);
+        });
+    }
+    if (!Array.from(encoder.options).some((option) => option.value === cutterExportEncoder)) cutterExportEncoder = 'software';
+    encoder.value = cutterExportEncoder;
+    encoder.disabled = cutterExportProfile === 'archive';
+}
+
+async function loadCutterExportOptions(file: FileCapabilityReference, generation: number): Promise<void> {
+    let options: CutterExportOptions | null = null;
+    try {
+        options = await window.api.getCutterExportOptions();
+    } catch { }
+    if (generation !== cutterLoadGeneration || cutterFile !== file) return;
+    cutterExportOptions = options;
+    updateCutterExportControls(options);
+}
+
+function applyCutterProject(project: CutterProject): boolean {
+    if (!cutterEditorState || !cutterVideoInfo) return false;
+    if (Math.abs(project.duration - cutterEditorState.duration) > 1 / cutterEditorState.fps || Math.abs(project.fps - cutterEditorState.fps) > 0.01) return false;
+    cutterEditorState = {
+        duration: cutterEditorState.duration,
+        fps: cutterEditorState.fps,
+        trimStart: project.trimStart,
+        trimEnd: project.trimEnd,
+        cuts: project.cuts.map((cut) => ({ ...cut })),
+    };
+    cutterExportProfile = project.profile;
+    cutterExportEncoder = project.encoder;
+    cutterAudioStreamIndex = project.audioStreamIndex;
+    updateCutterAudioStreams();
+    updateCutterExportControls(cutterExportOptions);
+    cutterHistoryPast = [];
+    cutterHistoryFuture = [];
+    cutterActiveCutId = null;
+    renderCutterEditor();
+    seekCutterVideo(cutterEditorState.trimStart);
+    return true;
+}
+
+async function recoverCutterProject(): Promise<void> {
+    if (!cutterPendingProject || !applyCutterProject(cutterPendingProject)) {
+        showAppToast('Projekt konnte nicht wiederhergestellt werden', 'warn');
+        return;
+    }
+    renderCutterProjectRecovery(null);
+    showAppToast('Projekt wiederhergestellt', 'info');
+}
+
+async function discardCutterProject(): Promise<void> {
+    if (!cutterFile) return;
+    try { await window.api.discardCutterProject(cutterFile.token); } catch { }
+    renderCutterProjectRecovery(null);
+}
+
+async function saveCutterProject(): Promise<void> {
+    await persistCutterProject(true);
+}
+
+async function openCutterProject(): Promise<void> {
+    if (!cutterFile || !await persistCutterProject(false)) return;
+    let project: CutterProject | null = null;
+    try { project = await window.api.openCutterProject(cutterFile.token); } catch { }
+    if (!project || !applyCutterProject(project)) {
+        showAppToast('Kein passendes Projekt gefunden', 'warn');
+        return;
+    }
+    renderCutterProjectRecovery(null);
+    showAppToast('Projekt geöffnet', 'info');
+}
+
+function setCutterExportProfile(value: string): void {
+    if (value !== 'quality' && value !== 'balanced' && value !== 'fast' && value !== 'archive') return;
+    cutterExportProfile = value;
+    if (value === 'archive') cutterExportEncoder = 'software';
+    updateCutterExportControls(cutterExportOptions);
+    scheduleCutterAutosave();
+}
+
+function setCutterExportEncoder(value: string): void {
+    if (value !== 'software' && value !== 'h264_nvenc' && value !== 'h264_qsv' && value !== 'h264_amf') return;
+    cutterExportEncoder = value;
+    scheduleCutterAutosave();
+}
+
+function setCutterAudioStream(value: string): void {
+    const index = Number(value);
+    if (!Number.isInteger(index) || index < 0 || !(cutterVideoInfo?.audioStreams ?? []).some((stream) => stream.index === index)) return;
+    cutterAudioStreamIndex = index;
+    scheduleCutterAutosave();
+}
+
 function commitCutterChange(before: CutterEditorState): void {
     if (!cutterEditorState || cutterStatesEqual(before, cutterEditorState)) return;
     cutterHistoryPast.push(cloneCutterState(before));
     if (cutterHistoryPast.length > 100) cutterHistoryPast.shift();
     cutterHistoryFuture = [];
     updateCutterHistoryButtons();
+    scheduleCutterAutosave();
 }
 
 function updateCutterHistoryButtons(): void {
@@ -718,6 +906,11 @@ function setCutterControlsEnabled(enabled: boolean): void {
     byId<HTMLButtonElement>('cutterZoomInBtn').disabled = !enabled;
     byId<HTMLButtonElement>('cutterZoomOutBtn').disabled = !enabled;
     byId<HTMLButtonElement>('cutterNewCutBtn').disabled = !enabled;
+    byId<HTMLButtonElement>('cutterSaveProjectBtn').disabled = !enabled;
+    byId<HTMLButtonElement>('cutterOpenProjectBtn').disabled = !enabled;
+    byId<HTMLSelectElement>('cutterExportProfile').disabled = !enabled;
+    byId<HTMLSelectElement>('cutterExportEncoder').disabled = !enabled || cutterExportProfile === 'archive';
+    byId<HTMLSelectElement>('cutterAudioStream').disabled = !enabled || (cutterVideoInfo?.audioStreams.length ?? 0) === 0;
     const volumeControl = document.querySelector<HTMLElement>('.cutter-volume-control');
     volumeControl?.classList.toggle('disabled', !enabled);
     volumeControl?.setAttribute('aria-disabled', String(!enabled));
@@ -872,6 +1065,11 @@ async function loadCutterFromPath(file: FileCapabilityReference): Promise<void>
     cutterHistoryPast = [];
     cutterHistoryFuture = [];
     cutterActiveCutId = null;
+    cutterExportProfile = 'balanced';
+    cutterExportEncoder = 'software';
+    cutterAudioStreamIndex = media.info.audioStreams[0]?.index ?? 0;
+    renderCutterProjectRecovery(null);
+    updateCutterAudioStreams();
     cutterZoom = getInitialCutterZoom(media.info.duration);
     byId<HTMLInputElement>('cutterZoom').value = String(cutterZoom);
     byId<HTMLInputElement>('cutterFilePath').value = file.name;
@@ -899,6 +1097,13 @@ async function loadCutterFromPath(file: FileCapabilityReference): Promise<void>
     updateCutterZoom(cutterZoom);
     renderCutterEditor();
     updateCutterPlayhead(0);
+    void (async () => {
+        await loadCutterExportOptions(file, generation);
+        if (generation !== cutterLoadGeneration || cutterFile !== file) return;
+        let project: CutterProject | null = null;
+        try { project = await window.api.getCutterProjectRecovery(file.token); } catch { }
+        if (generation === cutterLoadGeneration && cutterFile === file) renderCutterProjectRecovery(project);
+    })();
     void requestCutterWaveform(file, media.jobId, generation);
     void requestCutterAssets();
 }
@@ -940,6 +1145,10 @@ function confirmCutterReplacement(file: FileCapabilityReference): Promise<boolea
 async function requestCutterVideoReplacement(file: FileCapabilityReference): Promise<void> {
     if (!file || isCutting) return;
     if (!await confirmCutterReplacement(file)) return;
+    if (cutterEditorState && !await persistCutterProject(false)) {
+        showAppToast('Projekt konnte nicht gespeichert werden', 'warn');
+        return;
+    }
     await loadCutterFromPath(file);
 }
 
@@ -1023,6 +1232,7 @@ function undoCutterEdit(): void {
     cutterActiveCutId = null;
     seekCutterVideo(cutterEditorState.trimStart);
     renderCutterEditor();
+    scheduleCutterAutosave();
 }
 
 function redoCutterEdit(): void {
@@ -1034,6 +1244,7 @@ function redoCutterEdit(): void {
     cutterActiveCutId = null;
     seekCutterVideo(cutterEditorState.trimStart);
     renderCutterEditor();
+    scheduleCutterAutosave();
 }
 
 function setCutterPreviewMode(enabled: boolean): void {
@@ -1397,6 +1608,9 @@ async function startCutting(): Promise<void> {
             trimStart: cutterEditorState.trimStart,
             trimEnd: cutterEditorState.trimEnd,
             cuts: cutterEditorState.cuts.map((cut) => ({ ...cut })),
+            profile: cutterExportProfile,
+            encoder: cutterExportEncoder,
+            audioStreamIndex: cutterAudioStreamIndex,
         });
         if (result.success) {
             showAppToast(UI_TEXT.cutter.exportSuccess, 'info');

src/renderer-globals.d.ts

@@ -168,6 +168,8 @@ interface VideoInfo {
     audioCodec: string | null;
     previewCompatible: boolean;
     variableFrameRate: boolean;
+    rotation: 0 | 90 | 180 | 270;
+    audioStreams: Array<{ index: number; codec: string; channels: number; language: string | null }>;
 }
 
 interface SecretStatus {
@@ -212,6 +214,26 @@ interface VideoEditExportRequest {
     trimStart: number;
     trimEnd: number;
     cuts: Array<{ id: string; start: number; end: number }>;
+    profile?: 'quality' | 'balanced' | 'fast' | 'archive';
+    encoder?: 'software' | 'h264_nvenc' | 'h264_qsv' | 'h264_amf';
+    audioStreamIndex?: number;
+}
+
+interface CutterProject {
+    source: { path: string; size: number; mtimeMs: number };
+    duration: number;
+    fps: number;
+    trimStart: number;
+    trimEnd: number;
+    cuts: Array<{ id: string; start: number; end: number }>;
+    profile: 'quality' | 'balanced' | 'fast' | 'archive';
+    encoder: 'software' | 'h264_nvenc' | 'h264_qsv' | 'h264_amf';
+    audioStreamIndex: number;
+}
+
+interface CutterExportOptions {
+    profiles: Array<{ id: 'quality' | 'balanced' | 'fast' | 'archive'; label: string; container: 'mp4' | 'mkv' }>;
+    hardwareEncoders: Array<'h264_nvenc' | 'h264_qsv' | 'h264_amf'>;
 }
 
 interface FileCapabilityReference {
@@ -451,6 +473,11 @@ interface ApiBridge {
     prepareVideoEditorWaveform(capability: string, jobId: number): Promise<VideoEditorWaveform | null>;
     prepareVideoEditorAssets(capability: string, jobId: number, profile: VideoEditorAssetProfile): Promise<VideoEditorAssets | null>;
     cancelVideoEditorAssets(jobId: number): Promise<boolean>;
+    getCutterProjectRecovery(capability: string): Promise<CutterProject | null>;
+    saveCutterProject(capability: string, project: Omit<CutterProject, 'source' | 'duration' | 'fps'>): Promise<boolean>;
+    discardCutterProject(capability: string): Promise<boolean>;
+    openCutterProject(capability: string): Promise<CutterProject | null>;
+    getCutterExportOptions(): Promise<CutterExportOptions | null>;
     exportVideoEdit(request: VideoEditExportRequest): Promise<{ success: boolean; outputCapability?: string; outputName: string | null; cancelled?: boolean }>;
     cancelVideoEdit(): Promise<boolean>;
     cutVideo(inputCapability: string, startTime: number, endTime: number): Promise<{ success: boolean; outputName: string | null }>;

src/styles.css

@@ -3174,6 +3174,23 @@ input[type="checkbox"].vod-select-checkbox {
     text-overflow: ellipsis;
 }
 
+.cutter-recovery-panel {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-top: 8px;
+    padding: 8px 10px;
+    color: var(--workspace-text, var(--text));
+    background: var(--workspace-control, rgba(255, 255, 255, 0.04));
+    border: 1px solid var(--workspace-border, rgba(255, 255, 255, 0.1));
+    border-radius: 8px;
+    font-size: 12px;
+}
+
+.cutter-recovery-panel span {
+    flex: 1;
+}
+
 .cutter-workspace {
     display: grid;
     grid-template-columns: 280px minmax(0, 1fr);
@@ -3354,6 +3371,25 @@ input[type="checkbox"].vod-select-checkbox {
     transform: translateX(16px);
 }
 
+.cutter-export-options {
+    padding: 11px;
+    display: grid;
+    grid-template-columns: minmax(0, 1fr);
+    gap: 6px;
+    background: var(--workspace-control, rgba(255, 255, 255, 0.04));
+    border: 1px solid var(--workspace-border, rgba(255, 255, 255, 0.08));
+    border-radius: 7px;
+}
+
+.cutter-export-options label {
+    color: var(--workspace-text-muted, var(--text-secondary));
+    font-size: 11px;
+}
+
+.cutter-export-options select {
+    min-width: 0;
+}
+
 .cutter-trim-card,
 .cutter-cut-section {
     padding: 11px;