libbitsub 1.12.0 → 1.13.0

package/dist/ts/renderers.js

@@ -7,7 +7,7 @@ import { fetchSubtitleAsset, fetchSubtitleText } from './range-loader';
 import { initWasm } from './wasm';
 import { getOrCreateWorker, sendToWorker } from './worker';
 import { canUseWorkerOffscreenRender } from './capabilities';
-import { binarySearchTimestamp, convertFrameData, createWorkerSessionId, createWorkerState, detectSubtitleFormat, getSubtitleBounds, isMksSource, setCacheLimit as applyCacheLimit, setCachedFrame } from './utils';
+import { binarySearchTimestamp, convertFrameData, createWorkerSessionId, createWorkerState, detectSubtitleFormat, getSubtitleBounds, isMksSource, setCacheLimit as applyCacheLimit, setCachedFrame, spliceTimestamps } from './utils';
 import { PgsParser, DvbParser, VobSubParserLowLevel } from './parsers';
 import { WebGPURenderer, isWebGPUSupported } from './webgpu-renderer';
 import { WebGL2Renderer, isWebGL2Supported } from './webgl2-renderer';
@@ -58,6 +58,8 @@ class BaseVideoSubtitleRenderer {
     tempCanvas = null;
     tempCtx = null;
     lastRenderedData = null;
+    /** Clear the canvas instead of holding the previous cue while the next bitmap decodes. */
+    clearStaleWhilePending = false;
     lastCueIndex = null;
     currentCueMetadata = null;
     parserMetadata = null;
@@ -69,6 +71,9 @@ class BaseVideoSubtitleRenderer {
     prefetchAfter = 0;
     streamingLoad = true;
     rangeRequests = true;
+    maxSubtitleBytes;
+    /** Aborted on dispose to cancel in-flight subtitle downloads. */
+    lifecycle = new AbortController();
     onEvent;
     onWarning;
     currentRendererBackend = null;
@@ -134,6 +139,20 @@ class BaseVideoSubtitleRenderer {
         this.prefetchAfter = Math.max(0, Math.floor(options.prefetchWindow?.after ?? 0));
         this.streamingLoad = options.streamingLoad !== false;
         this.rangeRequests = options.rangeRequests !== false;
+        this.maxSubtitleBytes = options.maxSubtitleBytes;
+    }
+    /** Fetch options bound to this renderer's lifetime and download budget. */
+    fetchOptions(preferRange, onProgress) {
+        return { preferRange, onProgress, signal: this.lifecycle.signal, maxBytes: this.maxSubtitleBytes };
+    }
+    /** Dispose this renderer's parser in the shared worker, if a session was started. */
+    releaseWorkerSession(state) {
+        state.workerReady = false;
+        const sessionId = state.sessionId;
+        if (!sessionId)
+            return;
+        const type = this.format === 'pgs' ? 'disposePgs' : this.format === 'dvb' ? 'disposeDvb' : 'disposeVobSub';
+        sendToWorker({ type, sessionId }).catch(() => { });
     }
     emitLoadProgress(format, progress, indexedCues) {
         this.emitEvent({
@@ -280,6 +299,8 @@ class BaseVideoSubtitleRenderer {
     startInit() {
         this.initPromise = this.init();
         this.initPromise.catch((error) => {
+            if (this.disposed)
+                return;
             this.emitEvent({
                 type: 'error',
                 format: this.format,
@@ -330,10 +351,20 @@ class BaseVideoSubtitleRenderer {
     /** Initialize the renderer. */
     async init() {
         await initWasm();
+        if (this.disposed)
+            return;
         this.createCanvas();
         await new Promise((resolve) => setTimeout(resolve, 0));
+        if (this.disposed)
+            return;
         await this.loadSubtitles();
+        // Loading may have created parsers or worker sessions after dispose() ran;
+        // dispose again to release them.
+        if (this.disposed)
+            return this.dispose();
         await this.ensureWorkerOffscreenAttached();
+        if (this.disposed)
+            return this.dispose();
         this.startRenderLoop();
     }
     shouldPreferWorkerOffscreen() {
@@ -498,8 +529,6 @@ class BaseVideoSubtitleRenderer {
             }
             this.useWorkerOffscreen = true;
             this.emitRendererBackend('worker-offscreen');
-            this.lastRenderedIndex = -1;
-            this.lastRenderedTime = -1;
             await sendToWorker({
                 type: 'resizeOffscreenCanvas',
                 sessionId,
@@ -518,6 +547,8 @@ class BaseVideoSubtitleRenderer {
                 details: { reason: error instanceof Error ? error.message : String(error) }
             }));
         }
+        if (this.useWorkerOffscreen)
+            this.reconcileBackendPresentation();
     }
     recreateCanvasForMainThreadFallback() {
         this.removeOwnedCanvas();
@@ -600,68 +631,112 @@ class BaseVideoSubtitleRenderer {
     }
     /** Initialize WebGPU renderer. */
     async initWebGPU(allowBackendFallback = true) {
+        if (this.disposed)
+            return;
+        let renderer = null;
         try {
-            this.webgpuRenderer = new WebGPURenderer();
-            await this.webgpuRenderer.init();
-            if (!this.canvas)
+            renderer = new WebGPURenderer();
+            this.webgpuRenderer = renderer;
+            await renderer.init();
+            if (this.disposed || !this.canvas) {
+                renderer.destroy();
                 return;
+            }
             const bounds = this.getVideoContentBounds();
             const pixelRatio = this.getDevicePixelRatio();
             const width = Math.max(1, bounds.width * pixelRatio);
             const height = Math.max(1, bounds.height * pixelRatio);
-            await this.webgpuRenderer.setCanvas(this.canvas, width, height);
-            this.useWebGPU = true;
-            this.emitRendererBackend('webgpu');
+            await renderer.setCanvas(this.canvas, width, height);
+            if (this.disposed) {
+                renderer.destroy();
+                return;
+            }
         }
         catch (error) {
-            this.webgpuRenderer?.destroy();
+            renderer?.destroy();
+            if (this.disposed)
+                return;
             this.webgpuRenderer = null;
             this.useWebGPU = false;
             this.onWebGPUFallback?.();
+            if (this.disposed)
+                return;
             if (allowBackendFallback && isWebGL2Supported()) {
                 void this.initWebGL2();
             }
             else {
                 this.preferWorkerOffscreenOrCanvas2D();
             }
+            return;
         }
+        this.useWebGPU = true;
+        this.emitRendererBackend('webgpu');
+        this.reconcileBackendPresentation();
     }
     /** Initialize WebGL2 renderer. */
     async initWebGL2(allowBackendFallback = true) {
+        if (this.disposed)
+            return;
+        let renderer = null;
         try {
-            this.webgl2Renderer = new WebGL2Renderer();
-            await this.webgl2Renderer.init();
-            if (!this.canvas)
+            renderer = new WebGL2Renderer();
+            this.webgl2Renderer = renderer;
+            await renderer.init();
+            if (this.disposed || !this.canvas) {
+                renderer.destroy();
                 return;
+            }
             const bounds = this.getVideoContentBounds();
             const pixelRatio = this.getDevicePixelRatio();
             const width = Math.max(1, bounds.width * pixelRatio);
             const height = Math.max(1, bounds.height * pixelRatio);
-            await this.webgl2Renderer.setCanvas(this.canvas, width, height);
-            this.useWebGL2 = true;
-            this.emitRendererBackend('webgl2');
+            await renderer.setCanvas(this.canvas, width, height);
+            if (this.disposed) {
+                renderer.destroy();
+                return;
+            }
         }
         catch (error) {
-            this.webgl2Renderer?.destroy();
+            renderer?.destroy();
+            if (this.disposed)
+                return;
             this.webgl2Renderer = null;
             this.useWebGL2 = false;
             this.onWebGL2Fallback?.();
+            if (this.disposed)
+                return;
             if (allowBackendFallback) {
                 this.preferWorkerOffscreenOrCanvas2D();
             }
             else {
                 this.initCanvas2D();
             }
+            return;
         }
+        this.useWebGL2 = true;
+        this.emitRendererBackend('webgl2');
+        this.reconcileBackendPresentation();
     }
     /** Initialize Canvas2D renderer. */
     initCanvas2D() {
-        if (!this.canvas)
+        if (this.disposed || !this.canvas)
             return;
         this.ctx = this.canvas.getContext('2d');
         this.useWebGPU = false;
         this.useWebGL2 = false;
         this.emitRendererBackend('canvas2d');
+        this.reconcileBackendPresentation();
+    }
+    /** A cue decoded before backend startup has not yet reached the canvas. */
+    reconcileBackendPresentation() {
+        if (this.disposed)
+            return;
+        this.invalidatePresentation();
+        this.lastRenderedIndex = -2;
+        this.lastRenderedTime = -1;
+        // Loading creates the temporary drawing canvas before starting presentation.
+        if (this.frameScheduler)
+            this.renderPausedFrame();
     }
     /** Called when video seeks. */
     onSeek() { }
@@ -779,6 +854,13 @@ class BaseVideoSubtitleRenderer {
             return;
         this.renderSynchronizedFrame({ mediaTime: this.video.currentTime, presentedFrames: null });
     }
+    /**
+     * Render the cue for a media time synchronously, whether or not the video is paused.
+     * Hosts call this from their own presented-frame callback so a cached cue paints on that frame.
+     */
+    renderAtMediaTime(mediaTime) {
+        this.renderSynchronizedFrame({ mediaTime, presentedFrames: null });
+    }
     renderSynchronizedFrame(tick) {
         if (this.disposed || !this.isLoaded)
             return;
@@ -853,7 +935,7 @@ class BaseVideoSubtitleRenderer {
             if (this.findCurrentIndex(this.getCurrentSynchronizationTime()) !== index)
                 return;
             this.lastRenderedIndex = -1;
-            this.renderPausedFrame();
+            this.renderAtMediaTime(this.getCurrentSynchronizationTime() - this.timeOffset);
         }, () => { });
     }
     recordRenderPerformance(renderTime, capturedAt, countAsDropped = true) {
@@ -904,12 +986,17 @@ class BaseVideoSubtitleRenderer {
         // If data is undefined, it means async loading is in progress
         // Keep showing the last frame only while waiting for async data
         // Note: null means "loaded but empty" (clear screen), undefined means "still loading"
+        let stalePending = false;
         if (data === undefined && this.lastRenderedData !== null && index >= 0) {
             // Check if this index has a pending render (truly async loading)
             // If not pending, it means the render returned no data immediately
             if (this.isPendingRender(index)) {
-                // Don't clear - keep showing the last frame while loading
-                return { status: 'pending', data: null, warning: null };
+                if (!this.clearStaleWhilePending) {
+                    // Don't clear - keep showing the last frame while loading
+                    return { status: 'pending', data: null, warning: null };
+                }
+                // The previous cue has ended: clear it below instead of holding it
+                stalePending = true;
             }
         }
         const renderIssue = index >= 0 ? (this.getWorkerRendererState().renderIssues.get(index) ?? null) : null;
@@ -927,6 +1014,9 @@ class BaseVideoSubtitleRenderer {
         if (index < 0) {
             return { status: 'cleared', data: null, warning: null };
         }
+        if (stalePending) {
+            return { status: 'pending', data: null, warning: null };
+        }
         if (warning) {
             return { status: 'failed', data: data ?? null, warning };
         }
@@ -1141,6 +1231,7 @@ class BaseVideoSubtitleRenderer {
     /** Dispose of all resources. */
     dispose() {
         this.disposed = true;
+        this.lifecycle.abort();
         this.invalidatePresentation();
         this.frameScheduler?.stop();
         this.frameScheduler = null;
@@ -1222,10 +1313,7 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
                 return;
             }
             if (!this.streamingLoad) {
-                const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(this.subUrl, {
-                    preferRange: this.rangeRequests,
-                    onProgress: (progress) => this.emitLoadProgress('pgs', progress, this.state.timestamps.length)
-                });
+                const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(this.subUrl, this.fetchOptions(this.rangeRequests, (progress) => this.emitLoadProgress('pgs', progress, this.state.timestamps.length)));
                 this.emitLoadProgress('pgs', { loaded: data.byteLength, total: total ?? data.byteLength, ratio: 1, rangeSupported, strategy }, 0);
                 await this.loadPgsBuffer(data, false);
                 this.onLoaded?.();
@@ -1235,11 +1323,19 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
             this.onLoaded?.();
         }
         catch (error) {
+            if (this.disposed)
+                return;
             const resolvedError = normalizeSubtitleError(error, { format: 'pgs' });
             this.emitEvent({ type: 'error', format: 'pgs', error: resolvedError });
             this.onError?.(resolvedError);
         }
     }
+    /** Resolve an append response, which may carry only new timestamps, to the full list. */
+    mergePgsTimestamps(response) {
+        if (response.timestampBase === undefined)
+            return response.timestamps;
+        return spliceTimestamps(this.state.timestamps, response.timestampBase, response.timestamps);
+    }
     applyPgsIndexState(metadata, timestamps, partial, usingWorker) {
         this.state.metadata = metadata;
         this.state.timestamps = timestamps;
@@ -1272,7 +1368,7 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
             }
             catch (workerError) {
                 this.state.useWorker = false;
-                this.state.workerReady = false;
+                this.releaseWorkerSession(this.state);
                 this.state.sessionId = null;
                 this.emitWorkerState(false, false, null, true);
                 this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'PGS worker initialization failed, falling back to main-thread rendering.', {
@@ -1323,12 +1419,13 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
                 if (response.type !== 'pgsProgress')
                     throw new Error('Unexpected PGS worker response');
                 added = response.added;
+                const timestamps = this.mergePgsTimestamps(response);
                 if (added > 0) {
-                    this.applyPgsIndexState(response.metadata, response.timestamps, true, true);
+                    this.applyPgsIndexState(response.metadata, timestamps, true, true);
                 }
                 else {
                     this.state.metadata = response.metadata;
-                    this.state.timestamps = response.timestamps;
+                    this.state.timestamps = timestamps;
                 }
             }
             else {
@@ -1426,6 +1523,7 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
             catch (workerError) {
                 this.state.useWorker = false;
                 this.emitWorkerState(false, false, this.state.sessionId, true);
+                this.releaseWorkerSession(this.state);
                 this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'PGS worker initialization failed, falling back to main-thread rendering.', {
                     format: 'pgs',
                     details: { reason: workerError instanceof Error ? workerError.message : String(workerError) }
@@ -1451,6 +1549,7 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
                 this.state.useWorker = false;
                 usedWorker = false;
                 this.emitWorkerState(false, false, this.state.sessionId, true);
+                this.releaseWorkerSession(this.state);
                 this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'PGS worker initialization failed, falling back to main-thread rendering.', {
                     format: 'pgs',
                     details: { reason: workerError instanceof Error ? workerError.message : String(workerError) }
@@ -1463,10 +1562,7 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
             this.pgsParser.reset();
         }
         try {
-            const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(url, {
-                preferRange: this.rangeRequests,
-                onProgress: (progress) => this.emitLoadProgress('pgs', progress, this.state.timestamps.length)
-            }, async (chunk, progress) => {
+            const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(url, this.fetchOptions(this.rangeRequests, (progress) => this.emitLoadProgress('pgs', progress, this.state.timestamps.length)), async (chunk, progress) => {
                 if (chunk.byteLength === 0)
                     return;
                 if (usedWorker && this.state.sessionId) {
@@ -1477,12 +1573,13 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
                         data: transferable
                     });
                     if (response.type === 'pgsProgress') {
+                        const timestamps = this.mergePgsTimestamps(response);
                         if (response.added > 0 || !indexedOnce) {
-                            this.applyPgsIndexState(response.metadata, response.timestamps, true, true);
+                            this.applyPgsIndexState(response.metadata, timestamps, true, true);
                             indexedOnce = true;
                         }
                         else {
-                            this.state.timestamps = response.timestamps;
+                            this.state.timestamps = timestamps;
                             this.state.metadata = response.metadata;
                         }
                     }
@@ -1536,12 +1633,15 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
             if (usedWorker) {
                 this.state.useWorker = false;
                 this.emitWorkerState(false, false, this.state.sessionId, true);
+                this.releaseWorkerSession(this.state);
             }
+            if (this.disposed)
+                throw error;
             this.emitWarning(createSubtitleWarning('RANGE_FALLBACK', 'Progressive PGS load failed; retrying with a full buffer fetch.', {
                 format: 'pgs',
                 details: { reason: error instanceof Error ? error.message : String(error) }
             }));
-            const { data } = await fetchSubtitleAsset(url, { preferRange: this.rangeRequests });
+            const { data } = await fetchSubtitleAsset(url, this.fetchOptions(this.rangeRequests));
             await this.loadPgsBuffer(data, false);
         }
     }
@@ -1718,12 +1818,9 @@ export class PgsRenderer extends BaseVideoSubtitleRenderer {
         this.state.frameCache.clear();
         this.state.renderIssues.clear();
         this.state.pendingRenders.clear();
-        if (this.state.useWorker && this.state.workerReady) {
-            sendToWorker({ type: 'disposePgs', sessionId: this.state.sessionId }).catch(() => { });
-        }
+        this.releaseWorkerSession(this.state);
         this.pgsParser?.dispose();
         this.pgsParser = null;
-        this.state.sessionId = null;
     }
 }
 /**
@@ -1739,10 +1836,8 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
     onLoading;
     onLoaded;
     onError;
-    // Async index lookup state
-    cachedIndex = -1;
-    cachedIndexTime = -1;
-    pendingIndexLookup = null;
+    // Cue end times (ms) for the main-thread index lookup in worker mode; starts live in state.timestamps
+    cueEnds = null;
     constructor(options) {
         super(options, 'vobsub');
         this.idxUrl =
@@ -1753,6 +1848,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
         this.onLoading = options.onLoading;
         this.onLoaded = options.onLoaded;
         this.onError = options.onError;
+        this.clearStaleWhilePending = true;
         applyCacheLimit(this.state, this.cacheLimit);
         this.startInit();
     }
@@ -1783,6 +1879,8 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
             this.onLoaded?.();
         }
         catch (error) {
+            if (this.disposed)
+                return;
             const resolvedError = normalizeSubtitleError(error, { format: 'vobsub' });
             this.emitEvent({ type: 'error', format: 'vobsub', error: resolvedError });
             this.onError?.(resolvedError);
@@ -1813,6 +1911,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
         catch (workerError) {
             this.state.useWorker = false;
             this.emitWorkerState(false, false, this.state.sessionId, true);
+            this.releaseWorkerSession(this.state);
             this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'VobSub worker initialization failed, falling back to main-thread rendering.', {
                 format: 'vobsub',
                 details: { reason: workerError instanceof Error ? workerError.message : String(workerError) }
@@ -1845,6 +1944,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
                     this.state.workerReady = true;
                     this.state.metadata = loadResponse.metadata;
                     this.state.timestamps = loadResponse.timestamps;
+                    await this.loadCueTable();
                     this.isLoaded = true;
                     this.setParserMetadata(loadResponse.metadata);
                     this.emitIndexed('vobsub', loadResponse.metadata, false);
@@ -1861,6 +1961,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
                 }
                 this.state.useWorker = false;
                 this.emitWorkerState(false, false, this.state.sessionId, true);
+                this.releaseWorkerSession(this.state);
                 this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'VobSub worker load failed, falling back to main-thread rendering.', {
                     format: 'vobsub',
                     details: { reason: workerError instanceof Error ? workerError.message : String(workerError) }
@@ -1877,10 +1978,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
         if (!this.subUrl) {
             throw createSubtitleDiagnosticError('MISSING_INPUT', 'No SUB content or URL provided.', { format: 'vobsub' });
         }
-        const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(this.subUrl, {
-            preferRange: this.rangeRequests && this.streamingLoad,
-            onProgress: (progress) => this.emitLoadProgress('vobsub', progress, this.state.timestamps.length)
-        });
+        const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(this.subUrl, this.fetchOptions(this.rangeRequests && this.streamingLoad, (progress) => this.emitLoadProgress('vobsub', progress, this.state.timestamps.length)));
         this.emitLoadProgress('vobsub', {
             loaded: data.byteLength,
             total: total ?? data.byteLength,
@@ -1896,9 +1994,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
             if (!this.idxUrl) {
                 throw createSubtitleDiagnosticError('MISSING_INPUT', 'No IDX content or URL provided.', { format: 'vobsub' });
             }
-            idxData = await fetchSubtitleText(this.idxUrl, {
-                onProgress: (progress) => this.emitLoadProgress('vobsub', progress, 0)
-            });
+            idxData = await fetchSubtitleText(this.idxUrl, this.fetchOptions(false, (progress) => this.emitLoadProgress('vobsub', progress, 0)));
         }
         let usedWorker = await this.ensureVobSubWorkerSession();
         if (usedWorker && this.state.sessionId) {
@@ -1929,6 +2025,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
                 usedWorker = false;
                 this.state.useWorker = false;
                 this.emitWorkerState(false, false, this.state.sessionId, true);
+                this.releaseWorkerSession(this.state);
                 this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'VobSub worker IDX load failed, falling back to main-thread rendering.', {
                     format: 'vobsub',
                     details: { reason: error instanceof Error ? error.message : String(error) }
@@ -1953,10 +2050,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
             if (!this.subUrl) {
                 throw createSubtitleDiagnosticError('MISSING_INPUT', 'No SUB content or URL provided.', { format: 'vobsub' });
             }
-            const fetched = await fetchSubtitleAsset(this.subUrl, {
-                preferRange: this.rangeRequests && this.streamingLoad,
-                onProgress: (progress) => this.emitLoadProgress('vobsub', progress, this.state.timestamps.length)
-            });
+            const fetched = await fetchSubtitleAsset(this.subUrl, this.fetchOptions(this.rangeRequests && this.streamingLoad, (progress) => this.emitLoadProgress('vobsub', progress, this.state.timestamps.length)));
             subData = fetched.data;
             this.emitLoadProgress('vobsub', {
                 loaded: subData.byteLength,
@@ -1976,6 +2070,7 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
             if (attachResponse.type === 'vobSubProgress') {
                 this.applyVobSubIndexState(attachResponse.metadata, attachResponse.timestamps, false, true, true);
                 this.state.workerReady = true;
+                await this.loadCueTable();
                 this.isLoaded = true;
                 this.emitWorkerState(true, true, this.state.sessionId);
                 return;
@@ -2045,50 +2140,53 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
     }
     findCurrentIndex(time) {
         if (this.state.useWorker && this.state.workerReady) {
-            const timeMs = time * 1000;
-            // Only use cache if time is very close (within 1 frame)
-            const timeDelta = timeMs - this.cachedIndexTime;
-            const cacheValid = this.cachedIndexTime >= 0 && Math.abs(timeDelta) < 17;
-            if (cacheValid) {
-                return this.cachedIndex;
-            }
-            // Start async lookup if not already pending
-            if (!this.pendingIndexLookup) {
-                const presentationToken = this.getPresentationToken();
-                const lookup = sendToWorker({
-                    type: 'findVobSubIndex',
-                    sessionId: this.state.sessionId,
-                    timeMs
-                }).then((response) => {
-                    if (!this.isCurrentPresentation(presentationToken))
-                        return this.cachedIndex;
-                    if (response.type === 'vobSubIndex') {
-                        const newIndex = response.index;
-                        const oldIndex = this.cachedIndex;
-                        this.cachedIndex = newIndex;
-                        this.cachedIndexTime = timeMs;
-                        // Force re-render if index changed (including to -1 for clear)
-                        if (oldIndex !== newIndex) {
-                            this.lastRenderedIndex = -2; // Use -2 to force update even when new index is -1
-                        }
-                    }
-                    return this.cachedIndex;
-                });
-                this.pendingIndexLookup = lookup;
-                void lookup.then(() => {
-                    if (this.pendingIndexLookup !== lookup)
-                        return;
-                    this.pendingIndexLookup = null;
-                    this.renderPausedFrame();
-                }, () => {
-                    if (this.pendingIndexLookup === lookup)
-                        this.pendingIndexLookup = null;
-                });
-            }
-            return this.cachedIndex;
+            return this.findIndexInCueTable(time);
         }
         return this.vobsubParser?.findIndexAtTimestamp(time) ?? -1;
     }
+    /** Synchronous lookup against the worker's cue table; mirrors the core parser's find_index_at_timestamp. */
+    findIndexInCueTable(time) {
+        const starts = this.state.timestamps;
+        const ends = this.cueEnds;
+        if (!ends || starts.length === 0)
+            return -1;
+        const timeMs = Math.max(0, Math.floor(time * 1000));
+        let low = 0;
+        let high = starts.length;
+        while (low < high) {
+            const mid = low + ((high - low) >> 1);
+            if (starts[mid] <= timeMs)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        const index = low > 0 ? low - 1 : 0;
+        if (timeMs < starts[index] || timeMs >= ends[index])
+            return -1;
+        return index;
+    }
+    /** Fetch cue end times once, after the worker holds the SUB data. Falls back to next-start ends. */
+    async loadCueTable() {
+        const starts = this.state.timestamps;
+        let ends = null;
+        try {
+            const response = await sendToWorker({ type: 'getVobSubTimestamps', sessionId: this.state.sessionId });
+            const received = response.endTimestamps;
+            if (received && received.length === starts.length)
+                ends = received;
+        }
+        catch {
+            /* fall back below */
+        }
+        if (!ends) {
+            ends = new Float64Array(starts.length);
+            for (let i = 0; i < starts.length; i++)
+                ends[i] = starts[i + 1] ?? starts[i] + 5000;
+        }
+        this.cueEnds = ends;
+        this.lastRenderedIndex = -1;
+        this.renderPausedFrame();
+    }
     renderAtIndex(index) {
         if (this.state.frameCache.has(index)) {
             return this.state.frameCache.get(index) ?? undefined;
@@ -2159,10 +2257,6 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
         this.state.frameCache.clear();
         this.state.renderIssues.clear();
         this.state.pendingRenders.clear();
-        // Clear cached index lookup on seek
-        this.cachedIndex = -1;
-        this.cachedIndexTime = -1;
-        this.pendingIndexLookup = null;
         if (this.state.useWorker && this.state.workerReady) {
             sendToWorker({ type: 'clearVobSubCache', sessionId: this.state.sessionId }).catch(() => { });
         }
@@ -2179,9 +2273,6 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
         this.state.renderIssues.clear();
         this.state.pendingRenders.clear();
         this.clearOffscreenFrameMetadata();
-        this.cachedIndex = -1;
-        this.cachedIndexTime = -1;
-        this.pendingIndexLookup = null;
         this.lastRenderedIndex = -1;
         if (this.state.useWorker && this.state.workerReady) {
             sendToWorker({ type: 'clearVobSubCache', sessionId: this.state.sessionId }).catch(() => { });
@@ -2270,14 +2361,12 @@ export class VobSubRenderer extends BaseVideoSubtitleRenderer {
         this.state.frameCache.clear();
         this.state.renderIssues.clear();
         this.state.pendingRenders.clear();
-        if (this.state.useWorker && this.state.workerReady) {
-            sendToWorker({ type: 'disposeVobSub', sessionId: this.state.sessionId }).catch(() => { });
-        }
+        this.releaseWorkerSession(this.state);
         this.vobsubParser?.dispose();
         this.vobsubParser = null;
-        this.state.sessionId = null;
     }
 }
+/** High-level DVB overlay renderer bound to a video element. */
 export class DvbRenderer extends BaseVideoSubtitleRenderer {
     dvbParser = null;
     endTimestamps = new Float64Array(0);
@@ -2312,10 +2401,7 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
                 return;
             }
             if (!this.streamingLoad) {
-                const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(this.subUrl, {
-                    preferRange: this.rangeRequests,
-                    onProgress: (progress) => this.emitLoadProgress('dvb', progress, this.state.timestamps.length)
-                });
+                const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(this.subUrl, this.fetchOptions(this.rangeRequests, (progress) => this.emitLoadProgress('dvb', progress, this.state.timestamps.length)));
                 this.emitLoadProgress('dvb', { loaded: data.byteLength, total: total ?? data.byteLength, ratio: 1, rangeSupported, strategy }, 0);
                 await this.loadDvbBuffer(data, false);
                 this.onLoaded?.();
@@ -2325,11 +2411,23 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
             this.onLoaded?.();
         }
         catch (error) {
+            if (this.disposed)
+                return;
             const resolvedError = normalizeSubtitleError(error, { format: 'dvb' });
             this.emitEvent({ type: 'error', format: 'dvb', error: resolvedError });
             this.onError?.(resolvedError);
         }
     }
+    /** Resolve an append response, which may carry only changed entries, to the full lists. */
+    mergeDvbTimestamps(response) {
+        const base = response.timestampBase;
+        if (base === undefined)
+            return { timestamps: response.timestamps, endTimestamps: response.endTimestamps };
+        return {
+            timestamps: spliceTimestamps(this.state.timestamps, base, response.timestamps),
+            endTimestamps: spliceTimestamps(this.endTimestamps, base, response.endTimestamps)
+        };
+    }
     applyDvbIndexState(metadata, timestamps, endTimestamps, partial, usingWorker) {
         this.state.metadata = metadata;
         this.state.timestamps = timestamps;
@@ -2363,7 +2461,7 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
             }
             catch (workerError) {
                 this.state.useWorker = false;
-                this.state.workerReady = false;
+                this.releaseWorkerSession(this.state);
                 this.state.sessionId = null;
                 this.emitWorkerState(false, false, null, true);
                 this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'DVB worker initialization failed, falling back to main-thread rendering.', {
@@ -2414,13 +2512,14 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
                 if (response.type !== 'dvbProgress')
                     throw new Error('Unexpected DVB worker response');
                 added = response.added;
+                const { timestamps, endTimestamps } = this.mergeDvbTimestamps(response);
                 if (added > 0) {
-                    this.applyDvbIndexState(response.metadata, response.timestamps, response.endTimestamps, true, true);
+                    this.applyDvbIndexState(response.metadata, timestamps, endTimestamps, true, true);
                 }
                 else {
                     this.state.metadata = response.metadata;
-                    this.state.timestamps = response.timestamps;
-                    this.endTimestamps = response.endTimestamps;
+                    this.state.timestamps = timestamps;
+                    this.endTimestamps = endTimestamps;
                 }
             }
             else {
@@ -2519,6 +2618,7 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
             catch (workerError) {
                 this.state.useWorker = false;
                 this.emitWorkerState(false, false, this.state.sessionId, true);
+                this.releaseWorkerSession(this.state);
                 this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'DVB worker initialization failed, falling back to main-thread rendering.', {
                     format: 'dvb',
                     details: { reason: workerError instanceof Error ? workerError.message : String(workerError) }
@@ -2544,6 +2644,7 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
                 this.state.useWorker = false;
                 usedWorker = false;
                 this.emitWorkerState(false, false, this.state.sessionId, true);
+                this.releaseWorkerSession(this.state);
                 this.emitWarning(createSubtitleWarning('WORKER_FALLBACK', 'DVB worker initialization failed, falling back to main-thread rendering.', {
                     format: 'dvb',
                     details: { reason: workerError instanceof Error ? workerError.message : String(workerError) }
@@ -2556,10 +2657,7 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
             this.dvbParser.reset();
         }
         try {
-            const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(url, {
-                preferRange: this.rangeRequests,
-                onProgress: (progress) => this.emitLoadProgress('dvb', progress, this.state.timestamps.length)
-            }, async (chunk, progress) => {
+            const { data, strategy, rangeSupported, total } = await fetchSubtitleAsset(url, this.fetchOptions(this.rangeRequests, (progress) => this.emitLoadProgress('dvb', progress, this.state.timestamps.length)), async (chunk, progress) => {
                 if (chunk.byteLength === 0)
                     return;
                 if (usedWorker && this.state.sessionId) {
@@ -2570,13 +2668,14 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
                         data: transferable
                     });
                     if (response.type === 'dvbProgress') {
+                        const { timestamps, endTimestamps } = this.mergeDvbTimestamps(response);
                         if (response.added > 0 || !indexedOnce) {
-                            this.applyDvbIndexState(response.metadata, response.timestamps, response.endTimestamps, true, true);
+                            this.applyDvbIndexState(response.metadata, timestamps, endTimestamps, true, true);
                             indexedOnce = true;
                         }
                         else {
-                            this.state.timestamps = response.timestamps;
-                            this.endTimestamps = response.endTimestamps;
+                            this.state.timestamps = timestamps;
+                            this.endTimestamps = endTimestamps;
                             this.state.metadata = response.metadata;
                         }
                     }
@@ -2631,12 +2730,15 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
             if (usedWorker) {
                 this.state.useWorker = false;
                 this.emitWorkerState(false, false, this.state.sessionId, true);
+                this.releaseWorkerSession(this.state);
             }
+            if (this.disposed)
+                throw error;
             this.emitWarning(createSubtitleWarning('RANGE_FALLBACK', 'Progressive DVB load failed; retrying with a full buffer fetch.', {
                 format: 'dvb',
                 details: { reason: error instanceof Error ? error.message : String(error) }
             }));
-            const { data } = await fetchSubtitleAsset(url, { preferRange: this.rangeRequests });
+            const { data } = await fetchSubtitleAsset(url, this.fetchOptions(this.rangeRequests));
             await this.loadDvbBuffer(data, false);
         }
     }
@@ -2816,13 +2918,10 @@ export class DvbRenderer extends BaseVideoSubtitleRenderer {
         this.state.frameCache.clear();
         this.state.renderIssues.clear();
         this.state.pendingRenders.clear();
-        if (this.state.useWorker && this.state.workerReady) {
-            sendToWorker({ type: 'disposeDvb', sessionId: this.state.sessionId }).catch(() => { });
-        }
+        this.releaseWorkerSession(this.state);
         this.dvbParser?.dispose();
         this.dvbParser = null;
         this.endTimestamps = new Float64Array(0);
-        this.state.sessionId = null;
     }
 }
 /**