From 1732a16ce2c2683f1e589b9e607bc80e472d376e Mon Sep 17 00:00:00 2001
From: tigerenwork <tigeren.work@gmail.com>
Date: Thu, 6 Aug 2026 23:34:14 +0800
Subject: [PATCH] fix(transcode): fast job teardown and resilient HLS delivery

- DELETE markKilled removes the job synchronously; FFmpeg is killed in the background so playlist/segment routes 404 immediately
- segment route waits up to 5s for in-progress segment writes
- centralize player teardown (pause, destroy HLS, clear media sources) to stop lingering audio/requests on close
- track and release transcode jobs on player close/reopen and reset format to avoid reusing killed job URLs
- add e2e transcode lifecycle test
---
 data/media.db                                 | Bin 212992 -> 212992 bytes
 src/app/api/transcode/[jobId]/route.ts        |  12 +-
 .../api/transcode/[jobId]/seg/[name]/route.ts |  14 +-
 src/components/artplayer-wrapper.tsx          | 253 +++++++++++-------
 src/components/unified-video-player.tsx       |  68 ++++-
 src/lib/transcode/orchestrator.ts             |  47 +++-
 tests/streaming/test-transcode-lifecycle.mjs  | 176 ++++++++++++
 7 files changed, 465 insertions(+), 105 deletions(-)
 create mode 100644 tests/streaming/test-transcode-lifecycle.mjs

diff --git a/data/media.db b/data/media.db
index 7491e10e0602984731e5c708ef00e153abdb632b..3412255a1296bbed81ac13b73c597e4d286eee45 100644
GIT binary patch
delta 10626
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

delta 2136
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

diff --git a/src/app/api/transcode/[jobId]/route.ts b/src/app/api/transcode/[jobId]/route.ts
index ddb66bd..279b2f2 100644
--- a/src/app/api/transcode/[jobId]/route.ts
+++ b/src/app/api/transcode/[jobId]/route.ts
@@ -6,6 +6,16 @@ export const dynamic = 'force-dynamic';
 
 export async function DELETE(_request: Request, { params }: { params: Promise<{ jobId: string }> }) {
   const { jobId } = await params;
-  await transcodeOrchestrator.kill(jobId, 'client closed');
+  // markKilled() synchronously removes the job from the in-memory map so that
+  // segment/playlist routes return 404 immediately. The FFmpeg process is then
+  // terminated in the background so this response returns in <10ms.
+  const proc = transcodeOrchestrator.markKilled(jobId);
+  if (proc) {
+    transcodeOrchestrator.killProcess(proc).catch(() => {});
+  } else {
+    // Job not found via markKilled (may have already been cleaned up) — still
+    // try the normal kill path in case state differs.
+    transcodeOrchestrator.kill(jobId, 'client closed').catch(() => {});
+  }
   return NextResponse.json({ success: true });
 }
diff --git a/src/app/api/transcode/[jobId]/seg/[name]/route.ts b/src/app/api/transcode/[jobId]/seg/[name]/route.ts
index 47e8635..7e48481 100644
--- a/src/app/api/transcode/[jobId]/seg/[name]/route.ts
+++ b/src/app/api/transcode/[jobId]/seg/[name]/route.ts
@@ -6,6 +6,18 @@ import { segmentPath } from '@/lib/transcode/playlist';
 export const runtime = 'nodejs';
 export const dynamic = 'force-dynamic';
 
+async function waitForSegment(filePath: string, timeoutMs = 5000): Promise<boolean> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (fs.existsSync(filePath)) {
+      const stat = fs.statSync(filePath);
+      if (stat.size > 0) return true;
+    }
+    await new Promise(resolve => setTimeout(resolve, 150));
+  }
+  return false;
+}
+
 export async function GET(_request: Request, { params }: { params: Promise<{ jobId: string; name: string }> }) {
   const { jobId, name } = await params;
   const job = transcodeOrchestrator.get(jobId);
@@ -15,7 +27,7 @@ export async function GET(_request: Request, { params }: { params: Promise<{ job
   }
 
   const resolvedPath = segmentPath(job.outDir, name);
-  if (!resolvedPath || !fs.existsSync(resolvedPath)) {
+  if (!resolvedPath || !(await waitForSegment(resolvedPath))) {
     return new Response(null, { status: 404 });
   }
 
diff --git a/src/components/artplayer-wrapper.tsx b/src/components/artplayer-wrapper.tsx
index 2bc8f82..045c882 100644
--- a/src/components/artplayer-wrapper.tsx
+++ b/src/components/artplayer-wrapper.tsx
@@ -48,6 +48,8 @@ export default function ArtPlayerWrapper({
   const containerRef = useRef<HTMLDivElement>(null);
   const playerRef = useRef<Artplayer | null>(null);
   const hlsInstanceRef = useRef<Hls | null>(null); // Store HLS instance for cleanup
+  const formatOverrideRef = useRef<VideoFormat | undefined>(formatOverride);
+  const mediaElementsRef = useRef<Set<HTMLVideoElement>>(new Set());
   const [format, setFormat] = useState<VideoFormat | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(true);
@@ -61,6 +63,102 @@ export default function ArtPlayerWrapper({
   const [localBookmarkCount, setLocalBookmarkCount] = useState(bookmarkCount);
   const [localAvgRating, setLocalAvgRating] = useState(avgRating);
   const hlsErrorHandlerRef = useRef<HLSErrorHandler | null>(null);
+  const hlsShuttingDownRef = useRef<boolean>(false); // Blocks HLS error-recovery after teardown
+
+  const cloneQualities = (qualities: VideoFormat['qualities']) => (
+    qualities?.map(quality => ({ ...quality })) || []
+  );
+
+  const resetArtPlayerContainer = () => {
+    if (!containerRef.current) return;
+    const el = containerRef.current as unknown as Record<string, unknown>;
+    for (const prop of ['$control_option', '$video', '$player', '$art']) {
+      try { delete el[prop]; } catch (_) { /* non-configurable */ }
+    }
+  };
+
+  const stopTrackedMedia = (clearSource: boolean) => {
+    mediaElementsRef.current.forEach(videoEl => {
+      videoEl.pause();
+      if (clearSource) {
+        videoEl.removeAttribute('src');
+        videoEl.load();
+      }
+    });
+
+    containerRef.current?.querySelectorAll<HTMLMediaElement>('video, audio').forEach(mediaEl => {
+      mediaEl.pause();
+      if (clearSource) {
+        mediaEl.removeAttribute('src');
+        mediaEl.load();
+      }
+    });
+
+    if (clearSource) {
+      document.querySelectorAll<HTMLMediaElement>('video, audio').forEach(mediaEl => {
+        mediaEl.pause();
+        mediaEl.removeAttribute('src');
+        mediaEl.load();
+      });
+    }
+  };
+
+  const releasePlayer = () => {
+    // Mark HLS as shutting down BEFORE stopping/destroying so that any
+    // in-flight error callbacks (NETWORK_ERROR → startLoad recovery) are blocked.
+    hlsShuttingDownRef.current = true;
+
+    // ──── Step 1: Immediately pause all media to stop audio output ────
+    // Only pause here — do NOT remove src or call load() yet, because
+    // HLS.js still owns the MediaSource on the <video> element.
+    // Calling video.load() while HLS owns the MediaSource puts the element
+    // in a conflicting state where HLS can't cleanly abort its XHR requests.
+    mediaElementsRef.current.forEach(videoEl => {
+      try { videoEl.pause(); } catch (_) { /* ignore */ }
+    });
+    containerRef.current?.querySelectorAll<HTMLMediaElement>('video, audio').forEach(el => {
+      try { el.pause(); } catch (_) { /* ignore */ }
+    });
+
+    // ──── Step 2: Destroy HLS.js (stops all network requests) ────
+    // Monkey-patch recovery methods so in-flight error callbacks can't
+    // trigger a recovery loop between stopLoad() and destroy().
+    if (hlsInstanceRef.current) {
+      try {
+        hlsInstanceRef.current.startLoad = () => {};
+        (hlsInstanceRef.current as any).recoverMediaError = () => {};
+      } catch (_) { /* ignore */ }
+      // stopLoad() cancels pending fragment requests.
+      // destroy() internally calls detachMedia() (removes the MediaSource
+      // from the <video>) and aborts all remaining XHR — do NOT call
+      // detachMedia() separately, as that causes destroy() to skip XHR cleanup.
+      try { hlsInstanceRef.current.stopLoad(); } catch (_) { /* ignore */ }
+      try { hlsInstanceRef.current.destroy(); } catch (_) { /* ignore */ }
+      hlsInstanceRef.current = null;
+    }
+
+    hlsErrorHandlerRef.current?.detach();
+    hlsErrorHandlerRef.current = null;
+
+    // ──── Step 3: Clear media sources and destroy ArtPlayer ────
+    // Now that HLS is gone, scrub any remaining src/srcObject on media
+    // elements so the browser releases the underlying decode resources.
+    stopTrackedMedia(true);
+
+    if (playerRef.current) {
+      try { playerRef.current.pause(); } catch (_) { /* ignore */ }
+      try { playerRef.current.destroy(); } catch (_) { /* ignore */ }
+      playerRef.current = null;
+    }
+
+    mediaElementsRef.current.clear();
+    resetArtPlayerContainer();
+  };
+
+  const handleClose = () => {
+    releasePlayer();
+    onClose();
+  };
 
   // Prevent ALL scrolling when video player is open
   useEffect(() => {
@@ -127,10 +225,18 @@ export default function ArtPlayerWrapper({
     setLocalAvgRating(avgRating);
   }, [isBookmarked, bookmarkCount, avgRating]);
 
+  // Keep formatOverrideRef in sync (no re-init needed, handled separately)
+  useEffect(() => {
+    formatOverrideRef.current = formatOverride;
+  }, [formatOverride]);
+
   // Initialize ArtPlayer
   useEffect(() => {
     if (!useArtPlayer || !isOpen || !containerRef.current) return;
 
+    // Prevent duplicate instances/audio when React dev mode re-runs effects.
+    releasePlayer();
+
     // Inject custom styles to remove shadows
     const styleId = 'artplayer-styles';
     if (!document.getElementById(styleId)) {
@@ -144,7 +250,10 @@ export default function ArtPlayerWrapper({
     setError(null);
 
     try {
-      const detectedFormat = formatOverride || detectVideoFormat(video);
+      // Read from ref so this effect does NOT re-run when formatOverride changes
+      const detectedFormat = formatOverrideRef.current || detectVideoFormat(video);
+      const qualityOptions = cloneQualities(detectedFormat.qualities);
+      const settingsQualityOptions = cloneQualities(detectedFormat.qualities);
       setFormat(detectedFormat);
 
       // HLS.js plugin for ArtPlayer
@@ -186,7 +295,7 @@ export default function ArtPlayerWrapper({
         theme: '#3b82f6', // Blue theme
         
         // Quality control (for HLS)
-        quality: detectedFormat.qualities || [],
+        quality: qualityOptions,
         
         // Subtitle support
         subtitle: {
@@ -204,7 +313,7 @@ export default function ArtPlayerWrapper({
           {
             html: 'Quality',
             icon: '<span class="artplayer-icon-settings-quality">⚙️</span>',
-            selector: detectedFormat.qualities || [],
+            selector: settingsQualityOptions,
             onSelect: function(item: any) {
               console.log('Quality selected:', item);
               if (hlsInstance && item.level !== undefined) {
@@ -220,30 +329,45 @@ export default function ArtPlayerWrapper({
         // Custom initialization for HLS
         customType: {
           m3u8: function(video: HTMLVideoElement, url: string) {
+            mediaElementsRef.current.add(video);
             if (Hls.isSupported()) {
+              // Reset shutdown flag — we're starting fresh
+              hlsShuttingDownRef.current = false;
+
               hlsInstance = new Hls({
-                debug: process.env.NODE_ENV === 'development',
-                enableWorker: true,
-                lowLatencyMode: false, // Disable for better buffering
-                backBufferLength: 90,
-                maxBufferLength: 120, // Increase buffer length
-                maxBufferSize: 100 * 1000 * 1000, // 100MB buffer
-                maxBufferHole: 0.5, // Allow small holes
-                startLevel: -1, // Auto-select optimal quality
+                // Route HLS internal errors through console.warn so they don't
+                // trigger the Next.js dev overlay (which intercepts console.error).
+                debug: process.env.NODE_ENV === 'development' ? {
+                  trace: () => {},
+                  debug: () => {},
+                  log: () => {},
+                  info: () => {},
+                  warn: (...a: unknown[]) => console.debug('[HLS]', ...a),
+                  error: (...a: unknown[]) => console.warn('[HLS]', ...a),
+                } : false,
+                // Disable the web worker so XHR abort is synchronous on the main
+                // thread — eliminates worker-race requests after hls.destroy().
+                enableWorker: false,
+                lowLatencyMode: false,
+                backBufferLength: 30,
+                // Smaller buffer = fewer in-flight segments when user closes video.
+                maxBufferLength: 30,
+                maxBufferSize: 60 * 1000 * 1000, // 60MB
+                maxBufferHole: 0.5,
+                startLevel: -1,
                 capLevelToPlayerSize: true,
                 autoStartLoad: true,
                 maxFragLookUpTolerance: 0.25,
                 liveSyncDurationCount: 3,
                 liveMaxLatencyDurationCount: 10,
-                // Aggressive preloading for better buffering
                 manifestLoadingTimeOut: 10000,
-                manifestLoadingMaxRetry: 2,
+                // Fewer retries so recovery loops die quickly.
+                manifestLoadingMaxRetry: 1,
                 levelLoadingTimeOut: 10000,
-                levelLoadingMaxRetry: 2,
-                fragLoadingTimeOut: 20000, // Longer timeout for large segments
-                fragLoadingMaxRetry: 3,
-                // Bandwidth estimation settings
-                abrEwmaDefaultEstimate: 500000, // 500kbps initial estimate
+                levelLoadingMaxRetry: 1,
+                fragLoadingTimeOut: 20000,
+                fragLoadingMaxRetry: 1,
+                abrEwmaDefaultEstimate: 500000,
                 abrBandWidthFactor: 0.95,
                 abrBandWidthUpFactor: 0.7,
               });
@@ -309,7 +433,10 @@ export default function ArtPlayerWrapper({
               });
               
               hlsInstance.on(Hls.Events.ERROR, (event: string, data: any) => {
-                console.error('HLS error details:', {
+                // If we're shutting down, ignore all errors — no recovery needed.
+                if (hlsShuttingDownRef.current) return;
+
+                console.warn('HLS error details:', {
                   type: data.type,
                   details: data.details,
                   fatal: data.fatal,
@@ -331,7 +458,7 @@ export default function ArtPlayerWrapper({
                       hlsInstance?.recoverMediaError();
                       break;
                     default:
-                      console.error('HLS fatal error, cannot recover');
+                      console.warn('HLS fatal error, cannot recover');
                       setError('HLS streaming failed. Falling back to direct playback.');
                       // This will trigger fallback in the parent component
                       break;
@@ -362,6 +489,10 @@ export default function ArtPlayerWrapper({
         }
       });
 
+      if (player.video) {
+        mediaElementsRef.current.add(player.video as HTMLVideoElement);
+      }
+
       // Event listeners
       player.on('ready', () => {
         console.log('ArtPlayer ready');
@@ -460,28 +591,7 @@ export default function ArtPlayerWrapper({
 
       return () => {
         console.log('[ArtPlayer] Starting cleanup...');
-        
-        // Stop HLS loading immediately
-        if (hlsInstanceRef.current) {
-          console.log('[ArtPlayer] Stopping HLS loading...');
-          hlsInstanceRef.current.stopLoad();
-          hlsInstanceRef.current.destroy();
-          hlsInstanceRef.current = null;
-        }
-        
-        // Destroy player
-        if (playerRef.current) {
-          console.log('[ArtPlayer] Destroying player...');
-          playerRef.current.destroy();
-          playerRef.current = null;
-        }
-        
-        // Clean up HLS error handler
-        if (hlsErrorHandlerRef.current) {
-          hlsErrorHandlerRef.current.detach();
-          hlsErrorHandlerRef.current = null;
-        }
-        
+        releasePlayer();
         console.log('[ArtPlayer] Cleanup completed');
       };
     } catch (error) {
@@ -489,7 +599,8 @@ export default function ArtPlayerWrapper({
       setError(`Failed to initialize player: ${error instanceof Error ? error.message : 'Unknown error'}`);
       setIsLoading(false);
     }
-  }, [useArtPlayer, isOpen, video, onProgress, volume, autoplay, formatOverride]);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [useArtPlayer, isOpen, video, onProgress, volume, autoplay]);
 
   useEffect(() => {
     const activeJobId = getTranscodeJobId(format?.url);
@@ -602,7 +713,7 @@ export default function ArtPlayerWrapper({
       switch (e.key) {
         case 'Escape':
           e.preventDefault();
-          onClose();
+          handleClose();
           break;
         case ' ':
           e.preventDefault();
@@ -635,32 +746,13 @@ export default function ArtPlayerWrapper({
 
     document.addEventListener('keydown', handleKeyDown);
     return () => document.removeEventListener('keydown', handleKeyDown);
-  }, [isOpen, onClose, isPlaying]);
+  }, [isOpen, isPlaying]);
 
   // Cleanup on unmount
   useEffect(() => {
     return () => {
       console.log('[ArtPlayer] Unmount cleanup...');
-      
-      // Stop HLS loading
-      if (hlsInstanceRef.current) {
-        console.log('[ArtPlayer] Stopping HLS on unmount...');
-        hlsInstanceRef.current.stopLoad();
-        hlsInstanceRef.current.destroy();
-        hlsInstanceRef.current = null;
-      }
-      
-      // Destroy player
-      if (playerRef.current) {
-        playerRef.current.destroy();
-        playerRef.current = null;
-      }
-      
-      // Clean up HLS error handler
-      if (hlsErrorHandlerRef.current) {
-        hlsErrorHandlerRef.current.detach();
-        hlsErrorHandlerRef.current = null;
-      }
+      releasePlayer();
       
       // Clean up custom styles
       const styleElement = document.getElementById('artplayer-styles');
@@ -674,34 +766,9 @@ export default function ArtPlayerWrapper({
   useEffect(() => {
     if (!isOpen) {
       console.log('[ArtPlayer] Modal closed, stopping HLS...');
-      
-      // Stop HLS loading immediately when modal closes
-      if (hlsInstanceRef.current) {
-        hlsInstanceRef.current.stopLoad();
-        hlsInstanceRef.current.destroy();
-        hlsInstanceRef.current = null;
-      }
-      
-      // Also destroy player when modal closes
-      if (playerRef.current) {
-        playerRef.current.destroy();
-        playerRef.current = null;
-      }
-      
-      // Clean up error handler
-      if (hlsErrorHandlerRef.current) {
-        hlsErrorHandlerRef.current.detach();
-        hlsErrorHandlerRef.current = null;
-      }
-      
-      const activeJobId = getTranscodeJobId(format?.url);
-      if (activeJobId) {
-        fetch(`/api/transcode/${activeJobId}`, { method: 'DELETE' }).catch(error => {
-          console.warn('[ArtPlayer] Failed to release transcode session:', error);
-        });
-      }
+      releasePlayer();
     }
-  }, [isOpen, format?.type, video.id]);
+  }, [isOpen]);
 
   if (!isOpen) return null;
 
@@ -710,7 +777,7 @@ export default function ArtPlayerWrapper({
       <div className="relative w-full h-full max-w-7xl max-h-[90vh] mx-auto my-8">
         {/* Close button */}
         <button
-          onClick={onClose}
+          onClick={handleClose}
           className="absolute top-4 right-4 z-20 bg-black/50 hover:bg-black/70 text-white rounded-full p-2 transition-colors"
         >
           <svg className="h-6 w-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
diff --git a/src/components/unified-video-player.tsx b/src/components/unified-video-player.tsx
index 94733ff..8ddceab 100644
--- a/src/components/unified-video-player.tsx
+++ b/src/components/unified-video-player.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
 import { detectVideoFormat, VideoFile } from '@/lib/video-format-detector';
 import ArtPlayerWrapper from '@/components/artplayer-wrapper';
 import LocalPlayerLauncher from '@/components/local-player-launcher';
@@ -46,6 +46,39 @@ export default function UnifiedVideoPlayer({
   const [ratingCheckLoading, setRatingCheckLoading] = useState(true);
   const [transcodeLoading, setTranscodeLoading] = useState(false);
   const [transcodeError, setTranscodeError] = useState<string | null>(null);
+  const [activeTranscodeJobId, setActiveTranscodeJobId] = useState<string | null>(null);
+  const activeTranscodeJobIdRef = useRef<string | null>(null);
+
+  // Keep ref in sync with state
+  useEffect(() => {
+    activeTranscodeJobIdRef.current = activeTranscodeJobId;
+  }, [activeTranscodeJobId]);
+
+  const releaseTranscodeJob = useCallback((jobId: string | null) => {
+    if (!jobId) return;
+    fetch(`/api/transcode/${jobId}`, { method: 'DELETE', keepalive: true }).catch(error => {
+      console.warn('[UnifiedVideoPlayer] Failed to release transcode job:', error);
+    });
+  }, []);
+
+  const resetDetectedFormat = useCallback(() => {
+    const detectedFormat = detectVideoFormat(video);
+    setFormat(detectedFormat);
+    setTranscodeError(null);
+    setTranscodeLoading(false);
+    return detectedFormat;
+  }, [video]);
+
+  const handleClose = useCallback(() => {
+    // Read from ref to get the latest value, not a stale closure
+    const jobId = activeTranscodeJobIdRef.current;
+    if (jobId) {
+      releaseTranscodeJob(jobId);
+      setActiveTranscodeJobId(null);
+    }
+    resetDetectedFormat();
+    onClose();
+  }, [onClose, releaseTranscodeJob, resetDetectedFormat]);
 
   // Check current bookmark status and rating when video opens
   useEffect(() => {
@@ -97,16 +130,23 @@ export default function UnifiedVideoPlayer({
     }
   };
 
-  // Detect format on mount
+  // Detect/reset format whenever a video is opened. This avoids reusing a killed HLS job URL
+  // after closing and reopening the same video.
   useEffect(() => {
-    if (video) {
+    if (video && isOpen) {
       console.log('[UnifiedVideoPlayer] Detecting format for video:', video);
-      const detectedFormat = detectVideoFormat(video);
+      // Read from ref to get latest jobId without needing it in deps
+      const prevJobId = activeTranscodeJobIdRef.current;
+      if (prevJobId) {
+        releaseTranscodeJob(prevJobId);
+        setActiveTranscodeJobId(null);
+      }
+      const detectedFormat = resetDetectedFormat();
       console.log('[UnifiedVideoPlayer] Detected format:', detectedFormat);
-      setFormat(detectedFormat);
       setIsLoading(false);
     }
-  }, [video]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [video, isOpen]);
 
   useEffect(() => {
     if (!isOpen || format?.type !== 'local-player' || process.env.NEXT_PUBLIC_ENABLE_LIVE_TRANSCODE !== 'true') {
@@ -128,6 +168,7 @@ export default function UnifiedVideoPlayer({
           throw new Error(data.error || 'Failed to start live transcode');
         }
         if (!cancelled) {
+          setActiveTranscodeJobId(data.jobId || null);
           setFormat({
             type: 'hls',
             supportLevel: 'hls',
@@ -152,6 +193,17 @@ export default function UnifiedVideoPlayer({
     };
   }, [isOpen, format?.type, video.id]);
 
+  // When the modal closes while a transcode job is active, kill it.
+  useEffect(() => {
+    if (isOpen) return;
+    const jobId = activeTranscodeJobIdRef.current;
+    if (!jobId) return;
+    releaseTranscodeJob(jobId);
+    setActiveTranscodeJobId(null);
+    resetDetectedFormat();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isOpen]);
+
   // Handle ArtPlayer errors with recovery
   const handleArtPlayerError = useCallback((error: string) => {
     console.log('ArtPlayer encountered error:', error);
@@ -216,7 +268,7 @@ export default function UnifiedVideoPlayer({
         <LocalPlayerLauncher
           video={video}
           format={format}
-          onClose={onClose}
+          onClose={handleClose}
           onPlayerSelect={(playerId) => {
             console.log(`Selected player: ${playerId}`);
           }}
@@ -237,7 +289,7 @@ export default function UnifiedVideoPlayer({
       <ArtPlayerWrapper
         video={video}
         isOpen={isOpen}
-        onClose={onClose}
+        onClose={handleClose}
         onProgress={handleProgressUpdate}
         onBookmark={handleBookmarkToggle}
         onUnbookmark={handleUnbookmark}
diff --git a/src/lib/transcode/orchestrator.ts b/src/lib/transcode/orchestrator.ts
index 2fb0381..d9e8e9a 100644
--- a/src/lib/transcode/orchestrator.ts
+++ b/src/lib/transcode/orchestrator.ts
@@ -174,9 +174,52 @@ class TranscodeOrchestrator {
     return { reused: false, job: newJob };
   }
 
-  async kill(jobId: string, reason = 'client closed', cleanupDelay = getTranscodeConfig().cacheGraceMs): Promise<void> {
+  /**
+   * Synchronously remove the job from the in-memory map so that segment/playlist
+   * routes start returning 404 immediately. Returns the job's FFmpeg process (if
+   * still running) so the caller can kill it asynchronously in the background.
+   */
+  markKilled(jobId: string): ChildProcessWithoutNullStreams | null {
     const job = this.jobs.get(jobId);
-    if (!job) return;
+    if (!job || job.status === 'killed') return null;
+    job.status = 'killed';
+    job.error = 'client closed';
+    this.heartbeat.clear(jobId);
+    job.throttler?.stop();
+    this.gate.release();
+    this.jobs.delete(jobId);
+    // Persist status to DB so recovery on restart doesn't see stale jobs.
+    try {
+      getDatabase().prepare('UPDATE transcode_jobs SET status = ?, error = ? WHERE job_id = ?').run('killed', 'client closed', jobId);
+    } catch { /* best-effort */ }
+    // Schedule cleanup with the normal grace period.
+    this.janitor.scheduleCleanup(job.outDir, getTranscodeConfig().cacheGraceMs);
+    // Return the live process so the caller can terminate it asynchronously.
+    return (job.process && job.process.exitCode === null) ? job.process : null;
+  }
+
+  /** Terminate a raw FFmpeg process (graceful → SIGTERM → SIGKILL). */
+  async killProcess(proc: ChildProcessWithoutNullStreams): Promise<void> {
+    if (proc.exitCode !== null) return;
+    try { proc.stdin.write('q\n'); } catch { /* already gone */ }
+    const exited = await waitForExit(proc, 3000);
+    if (!exited && proc.exitCode === null) {
+      proc.kill('SIGTERM');
+      await waitForExit(proc, 2000);
+    }
+    if (proc.exitCode === null) {
+      proc.kill('SIGKILL');
+    }
+  }
+
+  async kill(jobId: string, reason = 'client closed', cleanupDelay = getTranscodeConfig().cacheGraceMs): Promise<void> {
+    // If markKilled() already ran, the job is gone from the map but we might
+    // still need to wait for FFmpeg to exit. Re-check via a local reference.
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      // Job was already removed by markKilled(); just return.
+      return;
+    }
 
     job.status = reason === 'completed' ? 'ready' : 'killed';
     job.error = reason === 'completed' ? undefined : reason;
diff --git a/tests/streaming/test-transcode-lifecycle.mjs b/tests/streaming/test-transcode-lifecycle.mjs
new file mode 100644
index 0000000..1240b93
--- /dev/null
+++ b/tests/streaming/test-transcode-lifecycle.mjs
@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+/**
+ * End-to-end test for the live transcoding lifecycle (v2 rewrite).
+ *
+ * Covers the staged changes:
+ *  - POST /api/transcode/start -> job + playlist URL
+ *  - master.m3u8 serves a VOD playlist immediately
+ *  - seg/ waits up to 5s for a segment to exist (waitForSegment)
+ *  - ping keeps the job alive; status reports it
+ *  - seek within the encoded window is reused (204)
+ *  - DELETE is fast (markKilled) and segment/playlist 404 immediately after
+ *  - the FFmpeg process actually exits afterwards
+ *  - repeated DELETE is idempotent
+ *
+ * Usage:
+ *   node tests/streaming/test-transcode-lifecycle.mjs [mediaId]
+ *
+ * Requires the dev server running with ENABLE_LIVE_TRANSCODE=true and a media
+ * row whose format decision is hls-remux or hls-transcode (e.g. a .mov).
+ */
+
+const BASE_URL = process.env.BASE_URL || 'http://localhost:3000';
+const MEDIA_ID = Number(process.argv[2] || process.env.TEST_MEDIA_ID || 127);
+
+let failures = 0;
+
+function ok(condition, label, extra = '') {
+  if (condition) {
+    console.log(`  ✅ ${label}${extra ? ` (${extra})` : ''}`);
+  } else {
+    failures += 1;
+    console.log(`  ❌ ${label}${extra ? ` (${extra})` : ''}`);
+  }
+}
+
+async function request(path, { method = 'GET', body, timeoutMs = 15_000 } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const startedAt = Date.now();
+  try {
+    const response = await fetch(`${BASE_URL}${path}`, {
+      method,
+      headers: body ? { 'Content-Type': 'application/json' } : undefined,
+      body: body ? JSON.stringify(body) : undefined,
+      signal: controller.signal,
+    });
+    const text = await response.text();
+    return {
+      status: response.status,
+      headers: response.headers,
+      body: text,
+      json: (() => { try { return JSON.parse(text); } catch { return null; } })(),
+      elapsedMs: Date.now() - startedAt,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function main() {
+  console.log(`🧪 Transcode lifecycle e2e — media #${MEDIA_ID} @ ${BASE_URL}`);
+  console.log('======================================================');
+
+  // ── 1. Start a transcode job ──────────────────────────────────────
+  console.log('\n1. Start transcode job');
+  const start = await request('/api/transcode/start', { method: 'POST', body: { mediaId: MEDIA_ID, startTime: 0 } });
+  ok(start.status === 200, 'POST /api/transcode/start -> 200', `elapsed ${start.elapsedMs}ms`);
+  if (start.status !== 200) {
+    console.log(`     response: ${start.body.slice(0, 300)}`);
+    process.exit(1);
+  }
+  const jobId = start.json.jobId;
+  const playlistUrl = start.json.playlistUrl;
+  ok(typeof jobId === 'string' && jobId.length > 0, 'jobId returned');
+  ok(typeof playlistUrl === 'string' && playlistUrl.includes(jobId), 'playlistUrl returned');
+  ok(start.json.decision === 'hls-remux' || start.json.decision === 'hls-transcode', `decision ${start.json.decision}`);
+
+  // ── 2. Playlist serves a VOD playlist ─────────────────────────────
+  console.log('\n2. Master playlist');
+  const playlist = await request(playlistUrl);
+  ok(playlist.status === 200, `GET ${playlistUrl} -> 200`, `elapsed ${playlist.elapsedMs}ms`);
+  ok(playlist.body.includes('#EXTM3U'), 'contains #EXTM3U');
+  ok(playlist.body.includes('#EXT-X-PLAYLIST-TYPE:VOD'), 'playlist type VOD');
+  const segmentMatch = playlist.body.match(/seg\/seg_\d{5}\.ts/);
+  ok(!!segmentMatch, 'references a segment file');
+
+  // ── 3. Segment delivery (includes waitForSegment path) ────────────
+  console.log('\n3. Segment delivery');
+  const firstSegmentName = segmentMatch[0].replace('seg/', '');
+  const firstSeg = await request(`/api/transcode/${jobId}/seg/${firstSegmentName}`);
+  ok(firstSeg.status === 200, `GET ${firstSegmentName} -> 200`, `elapsed ${firstSeg.elapsedMs}ms`);
+  ok(firstSeg.headers.get('content-type') === 'video/mp2t', 'content-type video/mp2t');
+  ok(Number(firstSeg.headers.get('content-length') || 0) > 0, 'segment non-empty');
+
+  // A segment a bit further ahead: waitForSegment polls until ffmpeg writes it.
+  const aheadIndex = String(30).padStart(5, '0');
+  const aheadName = `seg_${aheadIndex}.ts`;
+  const ahead = await request(`/api/transcode/${jobId}/seg/${aheadName}`, { timeoutMs: 10_000 });
+  ok(ahead.status === 200, `GET ${aheadName} (waitForSegment) -> 200`, `elapsed ${ahead.elapsedMs}ms`);
+
+  // A segment that will never exist: should poll for ~5s then 404.
+  const neverSeg = await request(`/api/transcode/${jobId}/seg/seg_99999.ts`, { timeoutMs: 10_000 });
+  ok(neverSeg.status === 404, 'GET seg_99999.ts -> 404', `elapsed ${neverSeg.elapsedMs}ms (expected ~5000)`);
+  ok(neverSeg.elapsedMs >= 4500, 'waited for segment before 404ing (poll path exercised)');
+
+  // ── 4. Ping keeps the job alive ───────────────────────────────────
+  console.log('\n4. Heartbeat ping');
+  const ping = await request(`/api/transcode/${jobId}/ping`, { method: 'POST', body: { position: 0, isPaused: false } });
+  ok(ping.status === 200 && ping.json?.success === true, 'POST ping -> 200');
+
+  const statusBefore = await request('/api/transcode/status');
+  const listed = statusBefore.json?.jobs?.find(j => j.id === jobId);
+  ok(statusBefore.status === 200 && !!listed, 'job appears in /api/transcode/status', listed ? `status=${listed.status}` : '');
+
+  // ── 5. Seek within the encoded window is reused ───────────────────
+  console.log('\n5. Seek within encoded window');
+  const seek = await request(`/api/transcode/${jobId}/seek`, { method: 'POST', body: { position: 0 } });
+  ok(seek.status === 204, 'POST seek {position:0} -> 204 (job reused)');
+
+  // ── 6. DELETE fast-path + immediate 404s ─────────────────────────
+  console.log('\n6. DELETE (markKilled fast path)');
+  const del = await request(`/api/transcode/${jobId}`, { method: 'DELETE' });
+  ok(del.status === 200 && del.json?.success === true, 'DELETE -> 200 success', `elapsed ${del.elapsedMs}ms`);
+  ok(del.elapsedMs < 1000, 'DELETE responds in <1s (markKilled is synchronous)', `${del.elapsedMs}ms`);
+
+  const playlistAfter = await request(playlistUrl);
+  ok(playlistAfter.status === 404, 'playlist 404 immediately after DELETE');
+  const segAfter = await request(`/api/transcode/${jobId}/seg/${firstSegmentName}`);
+  ok(segAfter.status === 404, 'segment 404 immediately after DELETE');
+
+  const statusAfter = await request('/api/transcode/status');
+  ok(!statusAfter.json?.jobs?.some(j => j.id === jobId), 'job removed from status');
+
+  // ── 7. FFmpeg process actually exits ──────────────────────────────
+  console.log('\n7. FFmpeg process termination');
+  await sleep(5000);
+  const { execSync } = await import('node:child_process');
+  let ffmpegStillRunning = false;
+  try {
+    const out = execSync(`pgrep -fl "${jobId}" || true`, { encoding: 'utf8' }).trim();
+    ffmpegStillRunning = out.length > 0;
+    if (ffmpegStillRunning) console.log(`     lingering: ${out}`);
+  } catch {
+    // pgrep unavailable — treat as pass-through, best-effort check
+  }
+  ok(!ffmpegStillRunning, 'no FFmpeg process remains for the job after grace period');
+
+  // ── 8. Idempotent DELETE ──────────────────────────────────────────
+  console.log('\n8. Idempotent DELETE');
+  const delAgain = await request(`/api/transcode/${jobId}`, { method: 'DELETE' });
+  ok(delAgain.status === 200, 'second DELETE -> 200 (no crash)');
+
+  // ── 9. Unknown job 404s ───────────────────────────────────────────
+  console.log('\n9. Unknown job handling');
+  const missing = await request('/api/transcode/00000000-0000-0000-0000-000000000000/master.m3u8');
+  ok(missing.status === 404, 'playlist for unknown job -> 404');
+
+  console.log('\n======================================================');
+  if (failures === 0) {
+    console.log(`🎉 ALL CHECKS PASSED (job ${jobId})`);
+    process.exit(0);
+  } else {
+    console.log(`💥 ${failures} check(s) FAILED (job ${jobId})`);
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error('❌ Test runner crashed:', error);
+  process.exit(1);
+});