From 7aaeffefcb4b97017091ccc3b9b378abec3ecde7 Mon Sep 17 00:00:00 2001
From: Jonathan Martins <finartcom@gmail.com>
Date: Wed, 16 Sep 2026 09:31:23 -0300
Subject: [PATCH] Fix export hanging forever at "preparing" and black preview
 after long minimize
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Export hang: ModernVideoExporter.export() awaits collectRuntimeDiagnostics()
as its very first step, before any progress is reported. That function calls
window.electronAPI.getExportHardwareInfo(), whose main-process handler awaits
app.getGPUInfo("complete") with no timeout. That Electron API can hang
indefinitely (never resolve or reject) when the GPU process is crashed,
disabled, or blocklisted, which silently stalls the entire export pipeline at
the "preparing" phase forever with no error ever surfaced. Race it against a
3s timeout in the main process, and add a defense-in-depth timeout around both
diagnostics IPC calls on the renderer side.

Black preview after minimizing: the editor's live preview renders through a
PixiJS WebGL/WebGPU canvas (VideoPlayback.tsx). Windows can reclaim GPU
resources from a window minimized/occluded for a long time, silently killing
the WebGL context with no recovery — nothing listened for
`webglcontextlost`/`contextrestored` or `visibilitychange` anywhere in the
app, so the canvas stayed permanently black until a full app relaunch. Add a
`webglcontextlost` listener that forces a full teardown/recreate of the Pixi
renderer (via a `rendererGeneration` counter), plus a `visibilitychange`
safety net that does the same after the window was hidden for over a minute,
to also cover the WebGPU backend (which doesn't fire that event) and stalled
hidden-<video> decoder sessions.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 electron/ipc/export/native-video.ts           | 15 +++++-
 src/components/video-editor/VideoPlayback.tsx | 49 ++++++++++++++++++-
 src/lib/exporter/modernVideoExporter.ts       | 28 ++++++++++-
 3 files changed, 88 insertions(+), 4 deletions(-)

diff --git a/electron/ipc/export/native-video.ts b/electron/ipc/export/native-video.ts
index 81b56b480..5fe2273a0 100644
--- a/electron/ipc/export/native-video.ts
+++ b/electron/ipc/export/native-video.ts
@@ -1944,6 +1944,8 @@ export function sanitizeExportGpuInfo(
 	return { machineModel, gpus };
 }
 
+const GPU_INFO_TIMEOUT_MS = 3000;
+
 /** Captures sanitized hardware and GPU acceleration details for export support reports. */
 export async function getExportHardwareInfo(): Promise<ExportHardwareInfo> {
 	let sanitizedGpuInfo: Pick<ExportHardwareInfo, "machineModel" | "gpus"> = {
@@ -1951,7 +1953,18 @@ export async function getExportHardwareInfo(): Promise<ExportHardwareInfo> {
 		gpus: [],
 	};
 	try {
-		sanitizedGpuInfo = sanitizeExportGpuInfo(await app.getGPUInfo("complete"));
+		// app.getGPUInfo("complete") can hang forever (never resolve or reject)
+		// when the GPU process is crashed, disabled, or blocklisted, which would
+		// otherwise stall the entire export pipeline at "preparing" with no
+		// error surfaced. Race it against a timeout so a stuck GPU process can
+		// never block exporting.
+		const gpuInfo = await Promise.race([
+			app.getGPUInfo("complete"),
+			new Promise<never>((_resolve, reject) =>
+				setTimeout(() => reject(new Error("getGPUInfo timed out")), GPU_INFO_TIMEOUT_MS),
+			),
+		]);
+		sanitizedGpuInfo = sanitizeExportGpuInfo(gpuInfo);
 	} catch {
 		// Hardware diagnostics are best effort and must not affect exporting.
 	}
diff --git a/src/components/video-editor/VideoPlayback.tsx b/src/components/video-editor/VideoPlayback.tsx
index 842343dc3..bac26cf53 100644
--- a/src/components/video-editor/VideoPlayback.tsx
+++ b/src/components/video-editor/VideoPlayback.tsx
@@ -393,6 +393,11 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 		const cameraContainerRef = useRef<Container | null>(null);
 		const [pixiReady, setPixiReady] = useState(false);
 		const videoReady = usePreviewVideoReady(videoRef, videoPath);
+		// Bumped to force a full teardown/recreate of the Pixi renderer after a
+		// lost WebGL/WebGPU context (e.g. Windows reclaiming GPU resources from a
+		// long-minimized window), since neither backend reliably self-recovers.
+		const [rendererGeneration, setRendererGeneration] = useState(0);
+		const contextLostCleanupRef = useRef<(() => void) | null>(null);
 
 		const [previewViewportWidth, setPreviewViewportWidth] = useState(640);
 		const [annotationSceneTransform, setAnnotationSceneTransform] =
@@ -1743,6 +1748,21 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 				appRef.current = app;
 				container.appendChild(app.canvas);
 
+				// A lost WebGL context (common after Windows reclaims GPU resources
+				// from a window minimized/occluded for a long time) leaves the canvas
+				// permanently black with no further Pixi errors. Force a full
+				// teardown/recreate rather than relying on browser-level restore,
+				// which PixiJS does not reliably resume from.
+				const canvasEl = app.canvas as unknown as HTMLCanvasElement;
+				const handleContextLost = (event: Event) => {
+					event.preventDefault();
+					console.warn("Preview renderer lost its GPU context; recreating.");
+					setRendererGeneration((generation) => generation + 1);
+				};
+				canvasEl.addEventListener("webglcontextlost", handleContextLost, false);
+				contextLostCleanupRef.current = () =>
+					canvasEl.removeEventListener("webglcontextlost", handleContextLost, false);
+
 				// Camera container - this will be scaled/positioned for zoom
 				const cameraContainer = new Container();
 				cameraContainerRef.current = cameraContainer;
@@ -1823,6 +1843,8 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 				motionBlurFilterRef.current?.destroy();
 				zoomBlurFilterRef.current = null;
 				motionBlurFilterRef.current = null;
+				contextLostCleanupRef.current?.();
+				contextLostCleanupRef.current = null;
 				destroyPixiApplication(app, "preview renderer");
 				appRef.current = null;
 				cameraContainerRef.current = null;
@@ -1831,7 +1853,32 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 				cursorContainerRef.current = null;
 				videoSpriteRef.current = null;
 			};
-		}, [initializePixiRenderer, onError, syncPreviewMotionBlurQuality]);
+		}, [initializePixiRenderer, onError, syncPreviewMotionBlurQuality, rendererGeneration]);
+
+		// Safety net for GPU context loss that doesn't fire `webglcontextlost`
+		// (e.g. the WebGPU backend, or a stalled hidden <video> decoder session)
+		// after the window was minimized/occluded for a long time.
+		useEffect(() => {
+			let hiddenAtMs: number | null = document.hidden ? performance.now() : null;
+			const RECOVERY_THRESHOLD_MS = 60_000;
+
+			const handleVisibilityChange = () => {
+				if (document.hidden) {
+					hiddenAtMs = performance.now();
+					return;
+				}
+
+				if (hiddenAtMs !== null && performance.now() - hiddenAtMs >= RECOVERY_THRESHOLD_MS) {
+					setRendererGeneration((generation) => generation + 1);
+				}
+				hiddenAtMs = null;
+			};
+
+			document.addEventListener("visibilitychange", handleVisibilityChange);
+			return () => {
+				document.removeEventListener("visibilitychange", handleVisibilityChange);
+			};
+		}, []);
 
 		// biome-ignore lint/correctness/useExhaustiveDependencies: A new media path must reset the persistent video element.
 		useEffect(() => {
diff --git a/src/lib/exporter/modernVideoExporter.ts b/src/lib/exporter/modernVideoExporter.ts
index 81137b267..2e3cb4528 100644
--- a/src/lib/exporter/modernVideoExporter.ts
+++ b/src/lib/exporter/modernVideoExporter.ts
@@ -192,6 +192,24 @@ type NativeAudioPlan =
 	  };
 
 const FILTERGRAPH_FALLBACK_AUDIO_SAMPLE_RATE = 48_000;
+const RUNTIME_DIAGNOSTICS_IPC_TIMEOUT_MS = 4000;
+
+/** Bounds a diagnostics-only IPC call so a stuck main process can never stall export prep. */
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T> {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new Error("Timed out")), timeoutMs);
+		promise.then(
+			(value) => {
+				clearTimeout(timer);
+				resolve(value);
+			},
+			(error) => {
+				clearTimeout(timer);
+				reject(error);
+			},
+		);
+	});
+}
 
 function hasNonDefaultSourceTrackSettings(sourceAudioTrackSettings?: SourceAudioTrackSettings) {
 	if (!sourceAudioTrackSettings) {
@@ -1015,7 +1033,10 @@ export class ModernVideoExporter {
 				typeof window !== "undefined" &&
 				typeof window.electronAPI?.getAppVersion === "function"
 			) {
-				diagnostics.appVersion = await window.electronAPI.getAppVersion();
+				diagnostics.appVersion = await withTimeout(
+					window.electronAPI.getAppVersion(),
+					RUNTIME_DIAGNOSTICS_IPC_TIMEOUT_MS,
+				);
 			}
 		} catch {
 			// Environment diagnostics must never prevent an export attempt.
@@ -1026,7 +1047,10 @@ export class ModernVideoExporter {
 				typeof window !== "undefined" &&
 				typeof window.electronAPI?.getExportHardwareInfo === "function"
 			) {
-				const result = await window.electronAPI.getExportHardwareInfo();
+				const result = await withTimeout(
+					window.electronAPI.getExportHardwareInfo(),
+					RUNTIME_DIAGNOSTICS_IPC_TIMEOUT_MS,
+				);
 				if (result.success && result.hardware) {
 					diagnostics.hardware = result.hardware;
 				}