libbitsub 1.10.2 → 1.12.0

package/dist/ts/worker.js

@@ -2,7 +2,7 @@
  * Web Worker management for libbitsub.
  * Handles off-main-thread subtitle parsing and rendering.
  */
-import { getWasmUrl } from './wasm';
+import { getWasmGlueUrl, getWasmUrl } from './wasm';
 let sharedWorker = null;
 let workerInitPromise = null;
 let messageId = 0;
@@ -15,60 +15,10 @@ export function isWorkerAvailable() {
 function createWorkerScript() {
     return `
 let wasmModule = null;
-let wasm;
-let cachedUint8Memory = null;
-let WASM_VECTOR_LEN = 0;
-let cachedTextEncoder = new TextEncoder();
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 const pgsParsers = new Map();
+const dvbParsers = new Map();
 const vobSubParsers = new Map();
-
-function getUint8Memory() {
-    if (cachedUint8Memory === null || cachedUint8Memory.byteLength === 0) {
-        cachedUint8Memory = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8Memory;
-}
-
-function passArray8ToWasm(arg) {
-    const ptr = wasm.__wbindgen_malloc(arg.length);
-    getUint8Memory().set(arg, ptr);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-const encodeString = typeof cachedTextEncoder.encodeInto === 'function'
-    ? function(arg, view) { return cachedTextEncoder.encodeInto(arg, view); }
-    : function(arg, view) {
-            const buf = cachedTextEncoder.encode(arg);
-            view.set(buf);
-            return { read: arg.length, written: buf.length };
-        };
-
-function passStringToWasm(arg) {
-    let len = arg.length;
-    let ptr = wasm.__wbindgen_malloc(len);
-    const mem = getUint8Memory();
-    let offset = 0;
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-    if (offset !== len) {
-        if (offset !== 0) arg = arg.slice(offset);
-        ptr = wasm.__wbindgen_realloc(ptr, len, len = offset + arg.length * 3);
-        const view = getUint8Memory().subarray(ptr + offset, ptr + len);
-        const ret = encodeString(arg, view);
-        offset += ret.written;
-    }
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function getStringFromWasm(ptr, len) {
-    return cachedTextDecoder.decode(getUint8Memory().subarray(ptr, ptr + len));
-}
+const offscreenSurfaces = new Map();
 
 function buildPgsMetadata(parser) {
     return {
@@ -79,6 +29,15 @@ function buildPgsMetadata(parser) {
     };
 }
 
+function buildDvbMetadata(parser) {
+    return {
+        format: 'dvb',
+        cueCount: parser.count,
+        screenWidth: parser.screenWidth || 0,
+        screenHeight: parser.screenHeight || 0
+    };
+}
+
 function buildVobSubMetadata(parser) {
     return {
         format: 'vobsub',
@@ -91,87 +50,162 @@ function buildVobSubMetadata(parser) {
     };
 }
 
+function detachOffscreenSurface(sessionId) {
+    offscreenSurfaces.delete(sessionId);
+}
+
 function disposeSession(sessionId) {
     const pgsParser = pgsParsers.get(sessionId);
     if (pgsParser) {
         pgsParser.free();
         pgsParsers.delete(sessionId);
     }
+    const dvbParser = dvbParsers.get(sessionId);
+    if (dvbParser) {
+        dvbParser.free();
+        dvbParsers.delete(sessionId);
+    }
     const vobSubParser = vobSubParsers.get(sessionId);
     if (vobSubParser) {
         vobSubParser.free();
         vobSubParsers.delete(sessionId);
     }
+    detachOffscreenSurface(sessionId);
+}
+
+function getCompositionBounds(compositions) {
+    if (!compositions || compositions.length === 0) return null;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const comp of compositions) {
+        minX = Math.min(minX, comp.x);
+        minY = Math.min(minY, comp.y);
+        maxX = Math.max(maxX, comp.x + comp.width);
+        maxY = Math.max(maxY, comp.y + comp.height);
+    }
+    if (!Number.isFinite(minX) || !Number.isFinite(minY)) return null;
+    return { x: minX, y: minY, width: Math.max(0, maxX - minX), height: Math.max(0, maxY - minY) };
 }
 
-async function initWasm(wasmUrl) {
-    if (wasm) return;
+function computeOffscreenLayout(frame, canvasWidth, canvasHeight, settings) {
+    const safeDataWidth = frame.width > 0 ? frame.width : canvasWidth;
+    const safeDataHeight = frame.height > 0 ? frame.height : canvasHeight;
+    const stretchScaleX = canvasWidth / safeDataWidth;
+    const stretchScaleY = canvasHeight / safeDataHeight;
+    const bounds = getCompositionBounds(frame.compositions) || {
+        x: 0, y: 0, width: safeDataWidth, height: safeDataHeight
+    };
+
+    const scale = settings.scale;
+    const aspectMode = settings.aspectMode;
+    const verticalOffset = settings.verticalOffset;
+    const horizontalOffset = settings.horizontalOffset;
+    const horizontalAlign = settings.horizontalAlign;
+    const bottomPadding = settings.bottomPadding;
+    const safeArea = settings.safeArea;
+    const opacity = settings.opacity;
 
-    const response = await fetch(wasmUrl);
-    if (!response.ok) {
-        throw new Error('Failed to fetch WASM: ' + response.status);
+    let baseScaleX = stretchScaleX;
+    let baseScaleY = stretchScaleY;
+    let frameShiftX = 0;
+    let frameShiftY = 0;
+
+    if (aspectMode !== 'stretch') {
+        const uniformScale = aspectMode === 'cover'
+            ? Math.max(stretchScaleX, stretchScaleY)
+            : Math.min(stretchScaleX, stretchScaleY);
+        baseScaleX = uniformScale;
+        baseScaleY = uniformScale;
+        frameShiftX = (canvasWidth - safeDataWidth * uniformScale) / 2;
+        frameShiftY = (canvasHeight - safeDataHeight * uniformScale) / 2;
     }
 
-    const wasmBytes = await response.arrayBuffer();
-    const result = await WebAssembly.instantiate(wasmBytes, {
-        __wbindgen_placeholder__: {
-            __wbindgen_throw: function(ptr, len) {
-                throw new Error(getStringFromWasm(ptr, len));
-            }
-        }
-    });
-    wasm = result.instance.exports;
-
-    wasmModule = {
-        PgsParser: class {
-            constructor() { this.ptr = wasm.pgsparser_new(); }
-            parse(data) {
-                const ptr = passArray8ToWasm(data);
-                return wasm.pgsparser_parse(this.ptr, ptr, WASM_VECTOR_LEN);
-            }
-            getTimestamps() { return wasm.pgsparser_getTimestamps(this.ptr); }
-            renderAtIndex(idx) { return wasm.pgsparser_renderAtIndex(this.ptr, idx); }
-            findIndexAtTimestamp(ts) { return wasm.pgsparser_findIndexAtTimestamp(this.ptr, ts); }
-            clearCache() { wasm.pgsparser_clearCache(this.ptr); }
-            free() { wasm.pgsparser_free(this.ptr); }
-            get count() { return wasm.pgsparser_count(this.ptr); }
-            get screenWidth() { return wasm.pgsparser_screenWidth(this.ptr); }
-            get screenHeight() { return wasm.pgsparser_screenHeight(this.ptr); }
-        },
-        VobSubParser: class {
-            constructor() { this.ptr = wasm.vobsubparser_new(); }
-            loadFromData(idx, sub) {
-                const idxPtr = passStringToWasm(idx);
-                const idxLen = WASM_VECTOR_LEN;
-                const subPtr = passArray8ToWasm(sub);
-                wasm.vobsubparser_loadFromData(this.ptr, idxPtr, idxLen, subPtr, sub.length);
-            }
-            loadFromMks(sub) {
-                const ptr = passArray8ToWasm(sub);
-                wasm.vobsubparser_loadFromMks(this.ptr, ptr, WASM_VECTOR_LEN);
-            }
-            loadFromSubOnly(sub) {
-                const ptr = passArray8ToWasm(sub);
-                wasm.vobsubparser_loadFromSubOnly(this.ptr, ptr, WASM_VECTOR_LEN);
-            }
-            getTimestamps() { return wasm.vobsubparser_getTimestamps(this.ptr); }
-            renderAtIndex(idx) { return wasm.vobsubparser_renderAtIndex(this.ptr, idx); }
-            findIndexAtTimestamp(ts) { return wasm.vobsubparser_findIndexAtTimestamp(this.ptr, ts); }
-            clearCache() { wasm.vobsubparser_clearCache(this.ptr); }
-            free() { wasm.vobsubparser_free(this.ptr); }
-            setDebandEnabled(enabled) { wasm.vobsubparser_setDebandEnabled(this.ptr, enabled); }
-            setDebandThreshold(threshold) { wasm.vobsubparser_setDebandThreshold(this.ptr, threshold); }
-            setDebandRange(range) { wasm.vobsubparser_setDebandRange(this.ptr, range); }
-            get count() { return wasm.vobsubparser_count(this.ptr); }
-            get screenWidth() { return wasm.vobsubparser_screenWidth(this.ptr); }
-            get screenHeight() { return wasm.vobsubparser_screenHeight(this.ptr); }
-            get language() { return wasm.vobsubparser_language(this.ptr); }
-            get trackId() { return wasm.vobsubparser_trackId(this.ptr); }
-            get hasIdxMetadata() { return !!wasm.vobsubparser_hasIdxMetadata(this.ptr); }
+    const anchorX = horizontalAlign === 'left'
+        ? bounds.x
+        : horizontalAlign === 'right'
+            ? bounds.x + bounds.width
+            : bounds.x + bounds.width / 2;
+    const anchorY = bounds.y + bounds.height;
+
+    const scaleX = baseScaleX * scale;
+    const scaleY = baseScaleY * scale;
+    const anchorShiftX = frameShiftX + anchorX * baseScaleX * (1 - scale);
+    const anchorShiftY = frameShiftY + anchorY * baseScaleY * (1 - scale);
+
+    let shiftX = anchorShiftX + (horizontalOffset / 100) * canvasWidth;
+    let shiftY = anchorShiftY + (verticalOffset / 100) * canvasHeight;
+    shiftY -= (bottomPadding / 100) * canvasHeight;
+
+    const safeX = (safeArea / 100) * canvasWidth;
+    const safeY = (safeArea / 100) * canvasHeight;
+    const finalMinX = bounds.x * scaleX + shiftX;
+    const finalMinY = bounds.y * scaleY + shiftY;
+    const finalMaxX = (bounds.x + bounds.width) * scaleX + shiftX;
+    const finalMaxY = (bounds.y + bounds.height) * scaleY + shiftY;
+
+    if (finalMinX < safeX) shiftX += safeX - finalMinX;
+    if (finalMaxX > canvasWidth - safeX) shiftX -= finalMaxX - (canvasWidth - safeX);
+    if (finalMinY < safeY) shiftY += safeY - finalMinY;
+    if (finalMaxY > canvasHeight - safeY) shiftY -= finalMaxY - (canvasHeight - safeY);
+
+    return { scaleX, scaleY, shiftX, shiftY, opacity };
+}
+
+function presentFrameToOffscreen(surface, frame, canvasWidth, canvasHeight, settings) {
+    const ctx = surface.ctx;
+    const canvas = surface.canvas;
+    if (canvas.width !== canvasWidth) canvas.width = canvasWidth;
+    if (canvas.height !== canvasHeight) canvas.height = canvasHeight;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+    if (!frame || !frame.compositions || frame.compositions.length === 0) {
+        return { status: frame ? 'empty' : 'cleared', width: frame?.width || 0, height: frame?.height || 0, compositionCount: 0 };
+    }
+
+    const layout = computeOffscreenLayout(frame, canvas.width, canvas.height, settings);
+    ctx.save();
+    ctx.globalAlpha = layout.opacity;
+
+    for (const comp of frame.compositions) {
+        if (!comp.width || !comp.height || !comp.rgba) continue;
+        if (surface.buffer.width !== comp.width || surface.buffer.height !== comp.height) {
+            surface.buffer.width = comp.width;
+            surface.buffer.height = comp.height;
         }
+        const pixels = comp.rgba instanceof Uint8ClampedArray
+            ? comp.rgba
+            : new Uint8ClampedArray(comp.rgba.buffer, comp.rgba.byteOffset, comp.rgba.byteLength);
+        surface.bufferCtx.putImageData(new ImageData(pixels, comp.width, comp.height), 0, 0);
+        const scaledWidth = comp.width * layout.scaleX;
+        const scaledHeight = comp.height * layout.scaleY;
+        const adjustedX = comp.x * layout.scaleX + layout.shiftX;
+        const adjustedY = comp.y * layout.scaleY + layout.shiftY;
+        ctx.drawImage(surface.buffer, adjustedX, adjustedY, scaledWidth, scaledHeight);
+    }
+
+    ctx.restore();
+    return {
+        status: 'rendered',
+        width: frame.width,
+        height: frame.height,
+        compositionCount: frame.compositions.length,
+        bounds: getCompositionBounds(frame.compositions)
     };
 }
 
+async function initWasm(wasmUrl, glueUrl) {
+    if (wasmModule) return;
+
+    let jsGlueUrl = glueUrl;
+    if (!jsGlueUrl) {
+        const derivedUrl = new URL(wasmUrl);
+        derivedUrl.pathname = derivedUrl.pathname.replace(/_bg\.wasm$/, '.js');
+        jsGlueUrl = derivedUrl.href;
+    }
+    const mod = await import(jsGlueUrl);
+    await mod.default({ module_or_path: wasmUrl });
+    wasmModule = mod;
+}
+
 function convertFrame(frame, isVobSub) {
     const compositions = [];
     if (isVobSub) {
@@ -205,7 +239,7 @@ self.onmessage = async function(event) {
     try {
         switch (request.type) {
             case 'init': {
-                await initWasm(request.wasmUrl);
+                await initWasm(request.wasmUrl, request.glueUrl);
                 postResponse({ type: 'initComplete', success: true }, [], _id);
                 break;
             }
@@ -222,6 +256,145 @@ self.onmessage = async function(event) {
                 );
                 break;
             }
+            case 'beginPgs': {
+                disposeSession(request.sessionId);
+                const parser = new wasmModule.PgsParser();
+                parser.reset();
+                pgsParsers.set(request.sessionId, parser);
+                const timestamps = parser.getTimestamps();
+                postResponse(
+                    { type: 'pgsProgress', count: 0, added: 0, partial: true, metadata: buildPgsMetadata(parser), timestamps },
+                    [timestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'appendPgs': {
+                let parser = pgsParsers.get(request.sessionId);
+                if (!parser) {
+                    parser = new wasmModule.PgsParser();
+                    parser.reset();
+                    pgsParsers.set(request.sessionId, parser);
+                }
+                const added = parser.feed(new Uint8Array(request.data));
+                const timestamps = parser.getTimestamps();
+                postResponse(
+                    { type: 'pgsProgress', count: parser.count, added, partial: true, metadata: buildPgsMetadata(parser), timestamps },
+                    [timestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'finishPgs': {
+                const parser = pgsParsers.get(request.sessionId);
+                if (!parser) {
+                    postResponse({ type: 'error', message: 'PGS session not found for finishPgs' }, [], _id);
+                    break;
+                }
+                const count = parser.finishFeed();
+                const timestamps = parser.getTimestamps();
+                postResponse(
+                    { type: 'pgsProgress', count, added: 0, partial: false, metadata: buildPgsMetadata(parser), timestamps },
+                    [timestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'resetPgs': {
+                let parser = pgsParsers.get(request.sessionId);
+                if (!parser) {
+                    parser = new wasmModule.PgsParser();
+                    pgsParsers.set(request.sessionId, parser);
+                }
+                parser.reset();
+                const timestamps = parser.getTimestamps();
+                postResponse(
+                    { type: 'pgsProgress', count: 0, added: 0, partial: true, metadata: buildPgsMetadata(parser), timestamps },
+                    [timestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'loadDvb': {
+                disposeSession(request.sessionId);
+                const parser = new wasmModule.DvbParser();
+                const count = parser.parse(new Uint8Array(request.data));
+                const timestamps = parser.getTimestamps();
+                const endTimestamps = parser.getEndTimestamps();
+                dvbParsers.set(request.sessionId, parser);
+                postResponse(
+                    { type: 'dvbLoaded', count, byteLength: request.data.byteLength, metadata: buildDvbMetadata(parser), timestamps, endTimestamps },
+                    [timestamps.buffer, endTimestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'beginDvb': {
+                disposeSession(request.sessionId);
+                const parser = new wasmModule.DvbParser();
+                parser.reset();
+                dvbParsers.set(request.sessionId, parser);
+                const timestamps = parser.getTimestamps();
+                const endTimestamps = parser.getEndTimestamps();
+                postResponse(
+                    { type: 'dvbProgress', count: 0, added: 0, partial: true, metadata: buildDvbMetadata(parser), timestamps, endTimestamps },
+                    [timestamps.buffer, endTimestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'appendDvb': {
+                let parser = dvbParsers.get(request.sessionId);
+                if (!parser) {
+                    parser = new wasmModule.DvbParser();
+                    parser.reset();
+                    dvbParsers.set(request.sessionId, parser);
+                }
+                const added = parser.feed(new Uint8Array(request.data));
+                const timestamps = parser.getTimestamps();
+                const endTimestamps = parser.getEndTimestamps();
+                postResponse(
+                    { type: 'dvbProgress', count: parser.count, added, partial: true, metadata: buildDvbMetadata(parser), timestamps, endTimestamps },
+                    [timestamps.buffer, endTimestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'finishDvb': {
+                const parser = dvbParsers.get(request.sessionId);
+                if (!parser) {
+                    postResponse({ type: 'error', message: 'DVB session not found for finishDvb' }, [], _id);
+                    break;
+                }
+                const previousCount = parser.count;
+                parser.finishFeed();
+                const count = parser.count;
+                const added = count - previousCount;
+                const timestamps = parser.getTimestamps();
+                const endTimestamps = parser.getEndTimestamps();
+                postResponse(
+                    { type: 'dvbProgress', count, added, partial: false, metadata: buildDvbMetadata(parser), timestamps, endTimestamps },
+                    [timestamps.buffer, endTimestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'resetDvb': {
+                let parser = dvbParsers.get(request.sessionId);
+                if (!parser) {
+                    parser = new wasmModule.DvbParser();
+                    dvbParsers.set(request.sessionId, parser);
+                }
+                parser.reset();
+                const timestamps = parser.getTimestamps();
+                const endTimestamps = parser.getEndTimestamps();
+                postResponse(
+                    { type: 'dvbProgress', count: 0, added: 0, partial: true, metadata: buildDvbMetadata(parser), timestamps, endTimestamps },
+                    [timestamps.buffer, endTimestamps.buffer],
+                    _id
+                );
+                break;
+            }
             case 'loadVobSub': {
                 disposeSession(request.sessionId);
                 const parser = new wasmModule.VobSubParser();
@@ -235,6 +408,48 @@ self.onmessage = async function(event) {
                 );
                 break;
             }
+            case 'loadVobSubIdx': {
+                disposeSession(request.sessionId);
+                const parser = new wasmModule.VobSubParser();
+                parser.loadFromIdx(request.idxContent);
+                const timestamps = parser.getTimestamps();
+                vobSubParsers.set(request.sessionId, parser);
+                postResponse(
+                    {
+                        type: 'vobSubProgress',
+                        count: parser.count,
+                        partial: true,
+                        hasSubData: !!parser.hasSubData,
+                        metadata: buildVobSubMetadata(parser),
+                        timestamps
+                    },
+                    [timestamps.buffer],
+                    _id
+                );
+                break;
+            }
+            case 'attachVobSubData': {
+                const parser = vobSubParsers.get(request.sessionId);
+                if (!parser) {
+                    postResponse({ type: 'error', message: 'VobSub session not found for attachVobSubData' }, [], _id);
+                    break;
+                }
+                parser.attachSubData(new Uint8Array(request.subData));
+                const timestamps = parser.getTimestamps();
+                postResponse(
+                    {
+                        type: 'vobSubProgress',
+                        count: parser.count,
+                        partial: false,
+                        hasSubData: !!parser.hasSubData,
+                        metadata: buildVobSubMetadata(parser),
+                        timestamps
+                    },
+                    [timestamps.buffer],
+                    _id
+                );
+                break;
+            }
             case 'loadVobSubMks': {
                 disposeSession(request.sessionId);
                 const parser = new wasmModule.VobSubParser();
@@ -271,6 +486,16 @@ self.onmessage = async function(event) {
                 postResponse({ type: 'pgsFrame', frame: frameData, renderIssue }, frameData.compositions.map((c) => c.rgba.buffer), _id);
                 break;
             }
+            case 'renderDvbAtIndex': {
+                const parser = dvbParsers.get(request.sessionId);
+                if (!parser) { postResponse({ type: 'dvbFrame', frame: null }, [], _id); break; }
+                const frame = parser.renderAtIndex(request.index);
+                const renderIssue = parser.lastRenderIssue || '';
+                if (!frame) { postResponse({ type: 'dvbFrame', frame: null, renderIssue }, [], _id); break; }
+                const frameData = convertFrame(frame, false);
+                postResponse({ type: 'dvbFrame', frame: frameData, renderIssue }, frameData.compositions.map((c) => c.rgba.buffer), _id);
+                break;
+            }
             case 'renderVobSubAtIndex': {
                 const parser = vobSubParsers.get(request.sessionId);
                 if (!parser) { postResponse({ type: 'vobSubFrame', frame: null }, [], _id); break; }
@@ -286,6 +511,11 @@ self.onmessage = async function(event) {
                 postResponse({ type: 'pgsIndex', index: parser ? parser.findIndexAtTimestamp(request.timeMs) : -1 }, [], _id);
                 break;
             }
+            case 'findDvbIndex': {
+                const parser = dvbParsers.get(request.sessionId);
+                postResponse({ type: 'dvbIndex', index: parser ? parser.findIndexAtTimestamp(request.timeMs) : -1 }, [], _id);
+                break;
+            }
             case 'findVobSubIndex': {
                 const parser = vobSubParsers.get(request.sessionId);
                 postResponse({ type: 'vobSubIndex', index: parser ? parser.findIndexAtTimestamp(request.timeMs) : -1 }, [], _id);
@@ -296,6 +526,11 @@ self.onmessage = async function(event) {
                 postResponse({ type: 'pgsTimestamps', timestamps: parser ? parser.getTimestamps() : new Float64Array(0) }, [], _id);
                 break;
             }
+            case 'getDvbTimestamps': {
+                const parser = dvbParsers.get(request.sessionId);
+                postResponse({ type: 'dvbTimestamps', timestamps: parser ? parser.getTimestamps() : new Float64Array(0) }, [], _id);
+                break;
+            }
             case 'getVobSubTimestamps': {
                 const parser = vobSubParsers.get(request.sessionId);
                 postResponse({ type: 'vobSubTimestamps', timestamps: parser ? parser.getTimestamps() : new Float64Array(0) }, [], _id);
@@ -306,6 +541,11 @@ self.onmessage = async function(event) {
                 postResponse({ type: 'cleared' }, [], _id);
                 break;
             }
+            case 'clearDvbCache': {
+                dvbParsers.get(request.sessionId)?.clearCache();
+                postResponse({ type: 'cleared' }, [], _id);
+                break;
+            }
             case 'clearVobSubCache': {
                 vobSubParsers.get(request.sessionId)?.clearCache();
                 postResponse({ type: 'cleared' }, [], _id);
@@ -320,6 +560,15 @@ self.onmessage = async function(event) {
                 postResponse({ type: 'disposed' }, [], _id);
                 break;
             }
+            case 'disposeDvb': {
+                const parser = dvbParsers.get(request.sessionId);
+                if (parser) {
+                    parser.free();
+                    dvbParsers.delete(request.sessionId);
+                }
+                postResponse({ type: 'disposed' }, [], _id);
+                break;
+            }
             case 'disposeVobSub': {
                 const parser = vobSubParsers.get(request.sessionId);
                 if (parser) {
@@ -344,63 +593,237 @@ self.onmessage = async function(event) {
                 postResponse({ type: 'debandSet' }, [], _id);
                 break;
             }
+            case 'attachOffscreenCanvas': {
+                const canvas = request.canvas;
+                if (!canvas || typeof canvas.getContext !== 'function') {
+                    throw new Error('OffscreenCanvas attach requires a transferable OffscreenCanvas');
+                }
+                if (offscreenSurfaces.has(request.sessionId)) {
+                    throw new Error('OffscreenCanvas already attached for this session');
+                }
+                const ctx = canvas.getContext('2d', { alpha: true, desynchronized: true });
+                if (!ctx) {
+                    throw new Error('OffscreenCanvas 2D context unavailable');
+                }
+                const buffer = new OffscreenCanvas(1, 1);
+                const bufferCtx = buffer.getContext('2d', { alpha: true, desynchronized: true });
+                if (!bufferCtx) {
+                    throw new Error('OffscreenCanvas buffer 2D context unavailable');
+                }
+                offscreenSurfaces.set(request.sessionId, { canvas, ctx, buffer, bufferCtx });
+                postResponse({ type: 'offscreenAttached' }, [], _id);
+                break;
+            }
+            case 'resizeOffscreenCanvas': {
+                const surface = offscreenSurfaces.get(request.sessionId);
+                if (surface) {
+                    const width = Math.max(1, request.width | 0);
+                    const height = Math.max(1, request.height | 0);
+                    if (surface.canvas.width !== width) surface.canvas.width = width;
+                    if (surface.canvas.height !== height) surface.canvas.height = height;
+                }
+                postResponse({ type: 'offscreenResized' }, [], _id);
+                break;
+            }
+            case 'detachOffscreenCanvas': {
+                detachOffscreenSurface(request.sessionId);
+                postResponse({ type: 'offscreenDetached' }, [], _id);
+                break;
+            }
+            case 'clearOffscreenCanvas': {
+                const surface = offscreenSurfaces.get(request.sessionId);
+                if (surface) {
+                    surface.ctx.clearRect(0, 0, surface.canvas.width, surface.canvas.height);
+                }
+                postResponse({ type: 'offscreenCleared' }, [], _id);
+                break;
+            }
+            case 'presentOffscreen': {
+                const surface = offscreenSurfaces.get(request.sessionId);
+                if (!surface) {
+                    postResponse({ type: 'offscreenPresented', status: 'failed', fatal: true, renderIssue: 'OFFSCREEN_SURFACE_MISSING' }, [], _id);
+                    break;
+                }
+
+                const canvasWidth = Math.max(1, request.canvasWidth | 0);
+                const canvasHeight = Math.max(1, request.canvasHeight | 0);
+                const settings = request.displaySettings || {
+                    scale: 1, aspectMode: 'stretch', verticalOffset: 0, horizontalOffset: 0,
+                    horizontalAlign: 'center', bottomPadding: 0, safeArea: 0, opacity: 1
+                };
+
+                if (request.index < 0) {
+                    if (surface.canvas.width !== canvasWidth) surface.canvas.width = canvasWidth;
+                    if (surface.canvas.height !== canvasHeight) surface.canvas.height = canvasHeight;
+                    surface.ctx.clearRect(0, 0, surface.canvas.width, surface.canvas.height);
+                    postResponse({ type: 'offscreenPresented', status: 'cleared', compositionCount: 0 }, [], _id);
+                    break;
+                }
+
+                let frame = null;
+                let renderIssue = '';
+                if (request.format === 'pgs') {
+                    const parser = pgsParsers.get(request.sessionId);
+                    if (!parser) {
+                        postResponse({ type: 'offscreenPresented', status: 'failed', fatal: true, renderIssue: 'PARSER_MISSING' }, [], _id);
+                        break;
+                    }
+                    const rendered = parser.renderAtIndex(request.index);
+                    renderIssue = parser.lastRenderIssue || '';
+                    frame = rendered ? convertFrame(rendered, false) : null;
+                } else if (request.format === 'dvb') {
+                    const parser = dvbParsers.get(request.sessionId);
+                    if (!parser) {
+                        postResponse({ type: 'offscreenPresented', status: 'failed', fatal: true, renderIssue: 'PARSER_MISSING' }, [], _id);
+                        break;
+                    }
+                    const rendered = parser.renderAtIndex(request.index);
+                    renderIssue = parser.lastRenderIssue || '';
+                    frame = rendered ? convertFrame(rendered, false) : null;
+                } else {
+                    const parser = vobSubParsers.get(request.sessionId);
+                    if (!parser) {
+                        postResponse({ type: 'offscreenPresented', status: 'failed', fatal: true, renderIssue: 'PARSER_MISSING' }, [], _id);
+                        break;
+                    }
+                    const rendered = parser.renderAtIndex(request.index);
+                    renderIssue = parser.lastRenderIssue || '';
+                    frame = rendered ? convertFrame(rendered, true) : null;
+                }
+
+                if (!frame) {
+                    if (surface.canvas.width !== canvasWidth) surface.canvas.width = canvasWidth;
+                    if (surface.canvas.height !== canvasHeight) surface.canvas.height = canvasHeight;
+                    surface.ctx.clearRect(0, 0, surface.canvas.width, surface.canvas.height);
+                    postResponse({
+                        type: 'offscreenPresented',
+                        status: renderIssue ? 'failed' : 'empty',
+                        renderIssue,
+                        compositionCount: 0
+                    }, [], _id);
+                    break;
+                }
+
+                const presented = presentFrameToOffscreen(surface, frame, canvasWidth, canvasHeight, settings);
+                postResponse({
+                    type: 'offscreenPresented',
+                    status: presented.status,
+                    renderIssue,
+                    width: presented.width,
+                    height: presented.height,
+                    compositionCount: presented.compositionCount,
+                    bounds: presented.bounds || null
+                }, [], _id);
+                break;
+            }
         }
     } catch (error) {
         postResponse({ type: 'error', message: error instanceof Error ? error.message : String(error) }, [], _id);
     }
 };`;
 }
+/** Whether the shared worker has finished WASM initialization. */
+export function isWorkerReady() {
+    return sharedWorker !== null;
+}
 /** Create or get the shared worker instance. */
 export function getOrCreateWorker() {
     if (sharedWorker)
         return Promise.resolve(sharedWorker);
     if (workerInitPromise)
         return workerInitPromise;
-    workerInitPromise = new Promise((resolve, reject) => {
+    const initPromise = initializeWorker();
+    workerInitPromise = initPromise;
+    void initPromise.then(() => {
+        if (workerInitPromise === initPromise)
+            workerInitPromise = null;
+    }, () => {
+        if (workerInitPromise === initPromise)
+            workerInitPromise = null;
+    });
+    return initPromise;
+}
+/** Pre-initialize the shared subtitle worker. */
+export function warmup() {
+    return ready();
+}
+/** Wait until the shared worker is ready for parse/render requests. */
+export async function ready() {
+    if (!isWorkerAvailable())
+        return;
+    if (sharedWorker)
+        return;
+    await getOrCreateWorker();
+}
+async function initializeWorker() {
+    const blob = new Blob([createWorkerScript()], { type: 'application/javascript' });
+    const workerUrl = URL.createObjectURL(blob);
+    let worker;
+    try {
+        worker = new Worker(workerUrl, { type: 'module' });
+    }
+    catch (error) {
+        URL.revokeObjectURL(workerUrl);
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+    worker.onmessage = (event) => {
+        const { _id, ...response } = event.data;
+        if (_id === undefined)
+            return;
+        const callback = pendingCallbacks.get(_id);
+        if (!callback)
+            return;
+        pendingCallbacks.delete(_id);
+        if (response.type === 'error' && callback.requestType === 'init') {
+            callback.reject(new Error(response.message));
+        }
+        else {
+            callback.resolve(response);
+        }
+    };
+    worker.onerror = (event) => {
+        const error = event instanceof ErrorEvent ? new Error(event.message) : new Error(String(event));
+        rejectWorkerCallbacks(worker, error);
+        if (sharedWorker === worker)
+            sharedWorker = null;
         try {
-            const blob = new Blob([createWorkerScript()], { type: 'application/javascript' });
-            const workerUrl = URL.createObjectURL(blob);
-            const worker = new Worker(workerUrl, { type: 'module' });
-            let initialized = false;
-            worker.onmessage = (event) => {
-                const { _id, ...response } = event.data;
-                if (_id !== undefined) {
-                    const callback = pendingCallbacks.get(_id);
-                    if (callback) {
-                        pendingCallbacks.delete(_id);
-                        callback.resolve(response);
-                    }
-                }
-            };
-            worker.onerror = (error) => {
-                if (!initialized) {
-                    URL.revokeObjectURL(workerUrl);
-                    worker.terminate();
-                    workerInitPromise = null;
-                    reject(error instanceof ErrorEvent ? new Error(error.message) : new Error(String(error)));
-                }
-            };
-            sendToWorkerInstance(worker, { type: 'init', wasmUrl: getWasmUrl() })
-                .then(() => {
-                URL.revokeObjectURL(workerUrl);
-                initialized = true;
-                sharedWorker = worker;
-                workerInitPromise = null;
-                resolve(worker);
-            })
-                .catch((err) => {
-                URL.revokeObjectURL(workerUrl);
-                worker.terminate();
-                workerInitPromise = null;
-                reject(err);
-            });
+            worker.terminate();
         }
-        catch (error) {
-            workerInitPromise = null;
-            reject(error instanceof Error ? error : new Error(String(error)));
+        catch {
+            /* ignore */
         }
-    });
-    return workerInitPromise;
+    };
+    try {
+        const initResponse = await sendToWorkerInstance(worker, {
+            type: 'init',
+            wasmUrl: getWasmUrl(),
+            glueUrl: getWasmGlueUrl()
+        });
+        if (initResponse.type === 'error') {
+            throw new Error(initResponse.message);
+        }
+        if (initResponse.type !== 'initComplete' || !initResponse.success) {
+            throw new Error('Worker WASM initialization failed');
+        }
+        sharedWorker = worker;
+        return worker;
+    }
+    catch (error) {
+        const workerError = error instanceof Error ? error : new Error(String(error));
+        rejectWorkerCallbacks(worker, workerError);
+        if (sharedWorker === worker)
+            sharedWorker = null;
+        try {
+            worker.terminate();
+        }
+        catch {
+            /* ignore */
+        }
+        throw workerError;
+    }
+    finally {
+        URL.revokeObjectURL(workerUrl);
+    }
 }
 /** Default timeout for worker operations (30 seconds for large files) */
 const WORKER_TIMEOUT = 30000;
@@ -419,6 +842,8 @@ function sendToWorkerInstance(worker, request, timeout = WORKER_TIMEOUT) {
             reject(new Error(`Worker operation timed out after ${timeout}ms`));
         }, timeout);
         pendingCallbacks.set(id, {
+            worker,
+            requestType: request.type,
             resolve: (response) => {
                 clearTimeout(timeoutId);
                 resolve(response);
@@ -433,7 +858,44 @@ function sendToWorkerInstance(worker, request, timeout = WORKER_TIMEOUT) {
             transfers.push(request.data);
         if ('subData' in request && request.subData instanceof ArrayBuffer)
             transfers.push(request.subData);
-        worker.postMessage({ ...request, _id: id }, transfers);
+        if ('canvas' in request && request.canvas)
+            transfers.push(request.canvas);
+        try {
+            worker.postMessage({ ...request, _id: id }, transfers);
+        }
+        catch (error) {
+            pendingCallbacks.delete(id);
+            clearTimeout(timeoutId);
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
     });
 }
+function rejectWorkerCallbacks(worker, error) {
+    for (const [id, callback] of pendingCallbacks) {
+        if (callback.worker !== worker)
+            continue;
+        pendingCallbacks.delete(id);
+        callback.reject(error);
+    }
+}
+/**
+ * Test-only helper: tear down shared worker state between Bun test files.
+ * Not part of the public runtime API.
+ */
+export function resetWorkerForTests() {
+    if (sharedWorker) {
+        try {
+            sharedWorker.terminate();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    sharedWorker = null;
+    workerInitPromise = null;
+    for (const [, callback] of pendingCallbacks) {
+        callback.reject(new Error('Worker reset for tests'));
+    }
+    pendingCallbacks.clear();
+}
 //# sourceMappingURL=worker.js.map