akarisub 0.2.0 → 0.2.1

package/dist/ts/ts/worker.js

@@ -0,0 +1,1695 @@
+/**
+ * AkariSub Worker - TypeScript implementation.
+ * Runs in a Web Worker to offload subtitle rendering from the main thread.
+ */
+/// <reference lib="webworker" />
+// @ts-ignore - WASM module is aliased during build
+import WASM from 'wasm';
+import { parseAss, dropBlur, fixPlayRes, libassYCbCrMap } from './utils';
+let lastCurrentTime = 0;
+let rate = 1;
+let rafId = null;
+let nextIsRaf = false;
+const nowMs = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
+let lastCurrentTimeReceivedAt = nowMs();
+let targetFps = 24;
+let onDemandRenderMode = false;
+let useLocalFonts = false;
+let blendMode = 'wasm';
+let availableFonts = {};
+const fontMap_ = {};
+let attachedFontId = 0; // For attached/preloaded fonts (higher priority)
+let fallbackFontId = 0; // For fallback fonts (lower priority)
+const pendingFallbackFonts = [];
+let debug = false;
+let clampPos = false;
+let renderInFlight = false;
+const MAX_QUEUED_RENDERS = 3;
+const queuedRenders = [];
+self.width = 0;
+self.height = 0;
+// Performance metrics
+const metrics = {
+    framesRendered: 0,
+    framesDropped: 0,
+    totalRenderTime: 0,
+    maxRenderTime: 0,
+    minRenderTime: Infinity,
+    lastRenderTime: 0,
+    renderStartTime: 0,
+    pendingRenders: 0,
+    totalEvents: 0,
+    currentEventIndex: 0,
+    cacheHits: 0,
+    cacheMisses: 0
+};
+const resetMetrics = () => {
+    metrics.framesRendered = 0;
+    metrics.framesDropped = 0;
+    metrics.totalRenderTime = 0;
+    metrics.maxRenderTime = 0;
+    metrics.minRenderTime = Infinity;
+    metrics.lastRenderTime = 0;
+    metrics.cacheHits = 0;
+    metrics.cacheMisses = 0;
+};
+let asyncRender = false;
+let asyncRenderOptions = true;
+let offCanvas = null;
+let offCanvasCtx = null;
+let offscreenRender = false;
+let bufferCanvas = null;
+let bufferCtx = null;
+let akariSubHandle = 0;
+let subtitleColorSpace = null;
+let dropAllBlur = false;
+let fullTrackWarmupEnabled = false;
+let hasBitmapBug = false;
+let _Module = null;
+let forceNextDemandRender = false;
+const TEXT_ENCODER = new TextEncoder();
+const TEXT_DECODER = new TextDecoder();
+let akariSubApi = null;
+// Pre-allocated object pool for render results
+const MAX_POOLED_IMAGES = 128;
+const RENDER_COLLECT_MAX_IMAGES = Math.max(MAX_POOLED_IMAGES, 4096);
+const PREWARM_MAX_IMAGES = RENDER_COLLECT_MAX_IMAGES;
+const WARMUP_AHEAD_SECONDS = 30;
+const WARMUP_STEP_SECONDS = 0.5;
+const WARMUP_TICK_MS = 40;
+const ENABLE_RUNTIME_WARMUP = false;
+const FULL_WARMUP_CAP_SECONDS = 30;
+const FULL_WARMUP_STEP_SECONDS = 1;
+const FULL_WARMUP_YIELD_EVERY = 24;
+const ASS_TIME_SCALE = 1000;
+const imagePool = new Array(MAX_POOLED_IMAGES);
+let poolInitialized = false;
+// Batch render-collect buffer: 3 header ints (changed, count, time) + 5 ints per image (x, y, w, h, image_ptr)
+const RRC_HEADER_INTS = 3;
+const RRC_IMG_STRIDE = 5;
+// Pre-allocated buffer for batch render-collect calls
+let rrcBufPtr = 0;
+let rrcBufCapacity = 0;
+const frameImages = [];
+const frameArrayBuffers = [];
+const frameBitmapPromises = [];
+let warmupTimer = null;
+let warmupCursorTime = 0;
+let warmupEndTime = 0;
+let warmupEnabled = false;
+let firstTrackEventStartTime = null;
+let fullTrackWarmupPromise = null;
+let protectedTrackContent = false;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const initPool = () => {
+    if (poolInitialized)
+        return;
+    for (let i = 0; i < MAX_POOLED_IMAGES; i++) {
+        imagePool[i] = { w: 0, h: 0, x: 0, y: 0, image: 0 };
+    }
+    poolInitialized = true;
+};
+const getPooledItem = (index) => {
+    if (index < MAX_POOLED_IMAGES) {
+        return imagePool[index];
+    }
+    return { w: 0, h: 0, x: 0, y: 0, image: 0 };
+};
+/**
+ * Ensure the batch render-collect buffer is large enough.
+ * Layout: [changed, count, time, (x, y, w, h, image_ptr) * N]
+ * = 3 + 5*N ints
+ */
+const ensureRenderCollectBuffer = (maxImages) => {
+    if (!_Module || maxImages <= 0)
+        return;
+    const totalInts = RRC_HEADER_INTS + RRC_IMG_STRIDE * maxImages;
+    if (rrcBufCapacity >= totalInts && rrcBufPtr)
+        return;
+    const nextCapacity = Math.max(totalInts, (rrcBufCapacity || 64) * 2);
+    const nextSizeBytes = nextCapacity * Int32Array.BYTES_PER_ELEMENT;
+    if (rrcBufPtr) {
+        _Module._free(rrcBufPtr);
+        rrcBufPtr = 0;
+        rrcBufCapacity = 0;
+    }
+    rrcBufPtr = _Module._malloc(nextSizeBytes);
+    if (!rrcBufPtr) {
+        rrcBufCapacity = 0;
+        throw new Error('Failed to allocate render-collect buffer');
+    }
+    rrcBufCapacity = nextCapacity;
+};
+const prewarmRenderer = (time) => {
+    if (!akariSubHandle)
+        return;
+    const api = requireApi();
+    const handle = requireHandle();
+    ensureRenderCollectBuffer(PREWARM_MAX_IMAGES);
+    if (blendMode === 'wasm') {
+        api.renderBlendCollect(handle, time, 0, rrcBufPtr, rrcBufCapacity);
+    }
+    else {
+        api.renderImageCollect(handle, time, 0, rrcBufPtr, rrcBufCapacity);
+    }
+};
+const syncTotalEventsMetric = () => {
+    metrics.totalEvents = akariSubHandle ? requireApi().getEventCount(akariSubHandle) : 0;
+};
+const getFirstEventStartTime = () => {
+    if (!akariSubHandle)
+        return null;
+    const api = requireApi();
+    const handle = requireHandle();
+    const count = api.getEventCount(handle);
+    if (count <= 0)
+        return null;
+    let firstStart = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < count; i++) {
+        const start = api.eventGetInt(handle, i, EVENT_INT_FIELDS.Start) / ASS_TIME_SCALE;
+        if (Number.isFinite(start) && start < firstStart) {
+            firstStart = start;
+        }
+    }
+    if (!Number.isFinite(firstStart))
+        return null;
+    return Math.max(0, firstStart);
+};
+const getTrackEventTimeRange = () => {
+    if (!akariSubHandle)
+        return null;
+    const api = requireApi();
+    const handle = requireHandle();
+    const count = api.getEventCount(handle);
+    if (count <= 0)
+        return null;
+    let start = Number.POSITIVE_INFINITY;
+    let end = 0;
+    for (let i = 0; i < count; i++) {
+        const eventStart = api.eventGetInt(handle, i, EVENT_INT_FIELDS.Start) / ASS_TIME_SCALE;
+        const eventDuration = Math.max(0, api.eventGetInt(handle, i, EVENT_INT_FIELDS.Duration) / ASS_TIME_SCALE);
+        if (!Number.isFinite(eventStart))
+            continue;
+        const eventEnd = eventStart + eventDuration;
+        if (eventStart < start)
+            start = eventStart;
+        if (eventEnd > end)
+            end = eventEnd;
+    }
+    if (!Number.isFinite(start))
+        return null;
+    if (end < start)
+        end = start;
+    return {
+        start: Math.max(0, start),
+        end: Math.max(0, end)
+    };
+};
+const prewarmEntireTrack = async () => {
+    if (!akariSubHandle)
+        return;
+    const range = getTrackEventTimeRange();
+    if (!range)
+        return;
+    const cappedEnd = Math.min(range.end, range.start + FULL_WARMUP_CAP_SECONDS);
+    let ticks = 0;
+    for (let time = range.start; time <= cappedEnd; time += FULL_WARMUP_STEP_SECONDS) {
+        if (!akariSubHandle)
+            return;
+        if (onDemandRenderMode && (renderInFlight || queuedRenders.length > 0 || metrics.pendingRenders > 0)) {
+            await sleep(0);
+            continue;
+        }
+        prewarmRenderer(time);
+        ticks++;
+        if (onDemandRenderMode || ticks % FULL_WARMUP_YIELD_EVERY === 0) {
+            await sleep(0);
+        }
+    }
+    prewarmRenderer(cappedEnd);
+};
+const getWarmupAnchorTime = (fallbackTime) => {
+    if (firstTrackEventStartTime == null)
+        return fallbackTime;
+    if (fallbackTime < firstTrackEventStartTime)
+        return firstTrackEventStartTime;
+    return fallbackTime;
+};
+const stopWarmup = () => {
+    warmupEnabled = false;
+    if (warmupTimer) {
+        clearTimeout(warmupTimer);
+        warmupTimer = null;
+    }
+};
+const scheduleFullTrackWarmup = () => {
+    if (!fullTrackWarmupEnabled || fullTrackWarmupPromise || !akariSubHandle)
+        return;
+    fullTrackWarmupPromise = (async () => {
+        await sleep(0);
+        try {
+            await prewarmEntireTrack();
+        }
+        catch (e) {
+            if (debug)
+                console.warn('[AkariSub] Full track warmup failed, continuing:', e);
+        }
+        try {
+            if (akariSubHandle) {
+                prewarmRenderer(getCurrentTime());
+            }
+        }
+        catch (e) {
+            if (debug)
+                console.warn('[AkariSub] Post-warmup re-prime failed, continuing:', e);
+        }
+    })().finally(() => {
+        fullTrackWarmupPromise = null;
+    });
+};
+const scheduleWarmupTick = () => {
+    if (!warmupEnabled || warmupTimer)
+        return;
+    warmupTimer = setTimeout(runWarmupTick, WARMUP_TICK_MS);
+};
+const startWarmupWindow = (fromTime) => {
+    if (!ENABLE_RUNTIME_WARMUP)
+        return;
+    if (!akariSubHandle || !Number.isFinite(fromTime))
+        return;
+    warmupCursorTime = fromTime;
+    warmupEndTime = fromTime + WARMUP_AHEAD_SECONDS;
+    warmupEnabled = true;
+    scheduleWarmupTick();
+};
+const runWarmupTick = () => {
+    warmupTimer = null;
+    if (!warmupEnabled || !akariSubHandle) {
+        warmupEnabled = false;
+        return;
+    }
+    if (warmupCursorTime >= warmupEndTime) {
+        warmupEnabled = false;
+        return;
+    }
+    if (renderInFlight || queuedRenders.length > 0 || metrics.pendingRenders > 0) {
+        scheduleWarmupTick();
+        return;
+    }
+    try {
+        const now = getCurrentTime();
+        if (warmupCursorTime < now) {
+            warmupCursorTime = now;
+        }
+        prewarmRenderer(warmupCursorTime);
+        warmupCursorTime += WARMUP_STEP_SECONDS;
+    }
+    catch (e) {
+        if (debug)
+            console.warn('[AkariSub] Warmup tick failed, continuing:', e);
+        warmupCursorTime += WARMUP_STEP_SECONDS;
+    }
+    scheduleWarmupTick();
+};
+const EVENT_INT_FIELDS = {
+    Start: 0,
+    Duration: 1,
+    ReadOrder: 2,
+    Layer: 3,
+    Style: 4,
+    MarginL: 5,
+    MarginR: 6,
+    MarginV: 7
+};
+const EVENT_STR_FIELDS = {
+    Name: 0,
+    Effect: 1,
+    Text: 2
+};
+const STYLE_NUM_FIELDS = {
+    FontSize: 0,
+    PrimaryColour: 1,
+    SecondaryColour: 2,
+    OutlineColour: 3,
+    BackColour: 4,
+    Bold: 5,
+    Italic: 6,
+    Underline: 7,
+    StrikeOut: 8,
+    ScaleX: 9,
+    ScaleY: 10,
+    Spacing: 11,
+    Angle: 12,
+    BorderStyle: 13,
+    Outline: 14,
+    Shadow: 15,
+    Alignment: 16,
+    MarginL: 17,
+    MarginR: 18,
+    MarginV: 19,
+    Encoding: 20,
+    treat_fontname_as_pattern: 21,
+    Blur: 22,
+    Justify: 23
+};
+const STYLE_STR_FIELDS = {
+    Name: 0,
+    FontName: 1
+};
+const encodeString = (input) => {
+    return TEXT_ENCODER.encode(input);
+};
+const allocString = (input) => {
+    if (!_Module)
+        return 0;
+    const bytes = encodeString(input);
+    const ptr = _Module._malloc(bytes.length + 1);
+    if (!ptr)
+        return 0;
+    self.HEAPU8.set(bytes, ptr);
+    self.HEAPU8[ptr + bytes.length] = 0;
+    return ptr;
+};
+const readCString = (ptr) => {
+    if (!ptr)
+        return '';
+    let end = ptr;
+    const heap = self.HEAPU8;
+    while (heap[end] !== 0)
+        end++;
+    return TEXT_DECODER.decode(heap.subarray(ptr, end));
+};
+const withCString = (input, callback) => {
+    const ptr = allocString(input);
+    try {
+        return callback(ptr);
+    }
+    finally {
+        if (ptr && _Module)
+            _Module._free(ptr);
+    }
+};
+const toUint8Array = (content) => {
+    return content instanceof Uint8Array ? content : new Uint8Array(content);
+};
+const isBinaryContent = (content) => {
+    return content instanceof Uint8Array || content instanceof ArrayBuffer;
+};
+const withCBytes = (input, callback) => {
+    if (!_Module)
+        throw new Error('AkariSub module is not initialized');
+    const ptr = _Module._malloc(input.length + 1);
+    if (!ptr)
+        throw new Error('Failed to allocate subtitle content');
+    try {
+        self.HEAPU8.set(input, ptr);
+        self.HEAPU8[ptr + input.length] = 0;
+        return callback(ptr);
+    }
+    finally {
+        self.HEAPU8.fill(0, ptr, ptr + input.length + 1);
+        _Module._free(ptr);
+    }
+};
+const decryptV2Payload = async (encrypted, contentKey) => {
+    const data = new Uint8Array(encrypted);
+    const keyIdSize = 8;
+    const nonceSize = 12;
+    const headerSize = 1 + keyIdSize + nonceSize;
+    if (data.length < headerSize + 16) {
+        throw new Error('Ciphertext too short for v2 subtitle payload');
+    }
+    if (data[0] !== 2) {
+        throw new Error('Unsupported encrypted subtitle protocol version');
+    }
+    const header = data.subarray(0, 1 + keyIdSize);
+    const nonce = data.subarray(1 + keyIdSize, headerSize);
+    const ciphertext = data.subarray(headerSize);
+    const decrypted = await crypto.subtle.decrypt({
+        name: 'AES-GCM',
+        iv: nonce.buffer.slice(nonce.byteOffset, nonce.byteOffset + nonce.byteLength),
+        additionalData: header.buffer.slice(header.byteOffset, header.byteOffset + header.byteLength),
+        tagLength: 128
+    }, contentKey, ciphertext.buffer.slice(ciphertext.byteOffset, ciphertext.byteOffset + ciphertext.byteLength));
+    return new Uint8Array(decrypted);
+};
+const decryptSubtitleContent = async (content) => {
+    if (content.encrypted) {
+        return decryptV2Payload(content.encrypted, content.contentKey);
+    }
+    const chunks = content.encryptedChunks || [];
+    if (chunks.length === 0) {
+        throw new Error('Encrypted subtitle content is empty');
+    }
+    const decryptedChunks = await Promise.all(chunks.map((chunk) => decryptV2Payload(chunk, content.contentKey)));
+    const totalLength = decryptedChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of decryptedChunks) {
+        result.set(chunk, offset);
+        chunk.fill(0);
+        offset += chunk.length;
+    }
+    return result;
+};
+const createTrackFromBytes = (content) => {
+    const api = requireApi();
+    const handle = requireHandle();
+    withCBytes(content, (contentPtr) => {
+        api.createTrackMem(handle, contentPtr);
+    });
+};
+const createTrackFromString = (content) => {
+    const api = requireApi();
+    const handle = requireHandle();
+    withCString(content, (contentPtr) => {
+        api.createTrackMem(handle, contentPtr);
+    });
+};
+const requireApi = () => {
+    if (!akariSubApi)
+        throw new Error('AkariSub API is not initialized');
+    return akariSubApi;
+};
+const requireHandle = () => {
+    if (!akariSubHandle)
+        throw new Error('AkariSub instance is not initialized');
+    return akariSubHandle;
+};
+// =============================================================================
+// Font Management
+// =============================================================================
+// Fonts added via addFont are explicitly requested, so they should be attached (high priority)
+self.addFont = ({ font }) => asyncWrite(font, false);
+const findAvailableFonts = (font) => {
+    font = font.trim().toLowerCase();
+    if (font.startsWith('@'))
+        font = font.substring(1);
+    if (fontMap_[font])
+        return;
+    fontMap_[font] = true;
+    if (!availableFonts[font]) {
+        if (useLocalFonts)
+            postMessage({ target: 'getLocalFont', font });
+    }
+    else {
+        asyncWrite(availableFonts[font]);
+    }
+};
+const asyncWrite = (font, isFallback = true) => {
+    if (typeof font === 'string') {
+        readAsync(font, (fontData) => {
+            writeFontToFS(new Uint8Array(fontData), isFallback);
+        }, console.error);
+    }
+    else {
+        writeFontToFS(font, isFallback);
+    }
+};
+// Synchronous font loading for critical fonts (fallback fonts)
+const syncWrite = (font, isFallback = true) => {
+    if (typeof font === 'string') {
+        const fontData = read_(font, true);
+        if (fontData) {
+            writeFontToFSImmediate(new Uint8Array(fontData), isFallback);
+        }
+    }
+    else {
+        writeFontToFSImmediate(font, isFallback);
+    }
+};
+// Debounced font reload
+let pendingFontReload = null;
+const scheduleReloadFonts = () => {
+    if (pendingFontReload)
+        return;
+    pendingFontReload = setTimeout(() => {
+        pendingFontReload = null;
+        if (akariSubHandle) {
+            const api = requireApi();
+            api.reloadFonts(akariSubHandle);
+        }
+    }, 16);
+};
+/**
+ * Add a font as an embedded font via ass_add_font.
+ * Embedded fonts have higher priority than fontconfig fonts in libass.
+ */
+const addFontAsEmbedded = (uint8, name) => {
+    if (!_Module || !akariSubHandle) {
+        if (debug)
+            console.warn('[AkariSub] Cannot add embedded font, module or AkariSub not ready:', name);
+        return;
+    }
+    try {
+        const api = requireApi();
+        // Allocate memory in WASM heap and copy font data
+        const ptr = _Module._malloc(uint8.length);
+        if (!ptr) {
+            console.warn('[AkariSub] Failed to allocate memory for embedded font:', name);
+            return;
+        }
+        // Copy font data to WASM heap
+        self.HEAPU8.set(uint8, ptr);
+        withCString(name, (namePtr) => {
+            api.addFont(akariSubHandle, namePtr, ptr, uint8.length);
+        });
+        if (debug)
+            console.log('[AkariSub] Added embedded font:', name, 'size:', uint8.length);
+    }
+    catch (e) {
+        console.warn('[AkariSub] Failed to add embedded font:', name, e);
+    }
+};
+/**
+ * Write a font to the virtual filesystem so fontconfig can index it.
+ * Fonts are written to separate directories based on priority:
+ * - /fonts/attached: For attached/preloaded fonts (highest priority)
+ * - /fonts/fallback: For fallback fonts
+ */
+const writeFontToFS = (uint8, isFallback = true) => {
+    const fontDir = isFallback ? '/fonts/fallback' : '/fonts/attached';
+    const fontFileName = isFallback ? 'fallback-' + fallbackFontId++ : 'attached-' + attachedFontId++;
+    if (_Module) {
+        try {
+            _Module.FS_createDataFile(fontDir, fontFileName, uint8, true, true, true);
+        }
+        catch (e) {
+            console.warn('Failed to write font to filesystem:', fontDir + '/' + fontFileName, e);
+        }
+        if (!isFallback) {
+            addFontAsEmbedded(uint8, fontFileName);
+        }
+        else if (akariSubHandle) {
+            addFontAsEmbedded(uint8, fontFileName);
+        }
+        else {
+            pendingFallbackFonts.push({ data: uint8, name: fontFileName });
+        }
+    }
+    scheduleReloadFonts();
+};
+/**
+ * Immediate font write without debounced reload (for synchronous loading).
+ */
+const writeFontToFSImmediate = (uint8, isFallback = true) => {
+    const fontDir = isFallback ? '/fonts/fallback' : '/fonts/attached';
+    const fontFileName = isFallback ? 'fallback-' + fallbackFontId++ : 'attached-' + attachedFontId++;
+    if (_Module) {
+        try {
+            _Module.FS_createDataFile(fontDir, fontFileName, uint8, true, true, true);
+            if (debug)
+                console.log('[AkariSub] Wrote font to FS:', fontDir + '/' + fontFileName, 'size:', uint8.length);
+        }
+        catch (e) {
+            console.warn('Failed to write font to filesystem:', fontDir + '/' + fontFileName, e);
+        }
+        if (!isFallback) {
+            addFontAsEmbedded(uint8, fontFileName);
+        }
+        else if (akariSubHandle) {
+            addFontAsEmbedded(uint8, fontFileName);
+        }
+        else {
+            pendingFallbackFonts.push({ data: uint8, name: fontFileName });
+        }
+    }
+};
+const processAvailableFonts = (content) => {
+    if (!availableFonts)
+        return;
+    const isLargeFile = content.length > 500000;
+    if (isLargeFile) {
+        // Extract only the styles section for large files
+        const stylesMatch = content.match(/\[V4\+?\s*Styles?\][^\[]*(?=\[|$)/i);
+        if (stylesMatch) {
+            const stylesSection = stylesMatch[0];
+            // Parse only the styles section
+            const styleFontMatches = stylesSection.matchAll(/^Style:[^,]*,([^,]+)/gm);
+            for (const match of styleFontMatches) {
+                findAvailableFonts(match[1].trim());
+            }
+        }
+        // For Events section in large files, limit to first 1000 \fn tags
+        const eventsMatch = content.match(/\[Events\][\s\S]*/i);
+        if (eventsMatch) {
+            const eventsContent = eventsMatch[0];
+            const fnMatches = eventsContent.matchAll(/\\fn([^\\}]*?)[\\}]/g);
+            let count = 0;
+            for (const match of fnMatches) {
+                findAvailableFonts(match[1]);
+                if (++count >= 1000)
+                    break;
+            }
+        }
+    }
+    else {
+        // Original behavior for small files
+        const sections = parseAss(content, true);
+        for (let i = 0; i < sections.length; i++) {
+            for (let j = 0; j < sections[i].body.length; j++) {
+                const entry = sections[i].body[j];
+                if (entry.key === 'Style' && typeof entry.value === 'object' && !Array.isArray(entry.value)) {
+                    findAvailableFonts(entry.value.Fontname);
+                }
+            }
+        }
+        // Use matchAll for Events section
+        const eventsMatch = content.match(/\[Events\][\s\S]*/i);
+        if (eventsMatch) {
+            const eventsContent = eventsMatch[0];
+            const fnMatches = eventsContent.matchAll(/\\fn([^\\}]*?)[\\}]/g);
+            for (const match of fnMatches) {
+                findAvailableFonts(match[1]);
+            }
+        }
+    }
+};
+// =============================================================================
+// Network Utilities
+// =============================================================================
+const read_ = (url, ab) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url, false);
+    xhr.responseType = ab ? 'arraybuffer' : 'text';
+    xhr.send(null);
+    return xhr.response;
+};
+const readAsync = (url, load, err) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.responseType = 'arraybuffer';
+    xhr.onload = () => {
+        if ((xhr.status === 200 || xhr.status === 0) && xhr.response) {
+            return load(xhr.response);
+        }
+    };
+    xhr.onerror = err;
+    xhr.send(null);
+};
+// =============================================================================
+// Track Management
+// =============================================================================
+const finishTrackLoad = () => {
+    const api = requireApi();
+    const handle = requireHandle();
+    syncTotalEventsMetric();
+    firstTrackEventStartTime = getFirstEventStartTime();
+    subtitleColorSpace = libassYCbCrMap[api.getTrackColorSpace(handle)];
+    forceNextDemandRender = true;
+    postMessage({ target: 'verifyColorSpace', subtitleColorSpace });
+    postMessage({ target: 'trackReady' });
+};
+self.setTrack = ({ content }) => {
+    stopWarmup();
+    fullTrackWarmupPromise = null;
+    protectedTrackContent = false;
+    if (isBinaryContent(content)) {
+        createTrackFromBytes(toUint8Array(content));
+        finishTrackLoad();
+        return;
+    }
+    processAvailableFonts(content);
+    if (clampPos)
+        content = fixPlayRes(content);
+    if (dropAllBlur)
+        content = dropBlur(content);
+    createTrackFromString(content);
+    finishTrackLoad();
+};
+self.setEncryptedTrack = async ({ content }) => {
+    stopWarmup();
+    fullTrackWarmupPromise = null;
+    protectedTrackContent = true;
+    const decrypted = await decryptSubtitleContent(content);
+    try {
+        createTrackFromBytes(decrypted);
+    }
+    finally {
+        decrypted.fill(0);
+    }
+    finishTrackLoad();
+};
+self.getColorSpace = () => {
+    postMessage({ target: 'verifyColorSpace', subtitleColorSpace });
+};
+self.freeTrack = () => {
+    stopWarmup();
+    fullTrackWarmupPromise = null;
+    firstTrackEventStartTime = null;
+    protectedTrackContent = false;
+    const api = requireApi();
+    const handle = requireHandle();
+    api.removeTrack(handle);
+    syncTotalEventsMetric();
+};
+self.setTrackByUrl = ({ url }) => {
+    self.setTrack({ content: read_(url) });
+};
+// =============================================================================
+// Time Management
+// =============================================================================
+let _isPaused = true;
+const getCurrentTime = () => {
+    const diff = (nowMs() - lastCurrentTimeReceivedAt) / 1000;
+    if (_isPaused) {
+        return lastCurrentTime;
+    }
+    else {
+        if (diff > 5) {
+            console.error("Didn't receive currentTime > 5 seconds. Assuming video was paused.");
+            setIsPaused(true);
+        }
+        return lastCurrentTime + diff * rate;
+    }
+};
+const setCurrentTime = (currentTime) => {
+    lastCurrentTime = currentTime;
+    lastCurrentTimeReceivedAt = nowMs();
+    if (onDemandRenderMode) {
+        return;
+    }
+    if (!rafId) {
+        if (nextIsRaf) {
+            rafId = requestAnimationFrame(renderLoop);
+        }
+        else {
+            renderLoop();
+            nextIsRaf = true;
+            setTimeout(() => {
+                nextIsRaf = false;
+            }, 20);
+        }
+    }
+};
+const setIsPaused = (isPaused) => {
+    if (onDemandRenderMode) {
+        _isPaused = isPaused;
+        if (rafId) {
+            cancelAnimationFrame(rafId);
+            rafId = null;
+        }
+        return;
+    }
+    if (isPaused !== _isPaused) {
+        _isPaused = isPaused;
+        if (isPaused) {
+            if (rafId) {
+                cancelAnimationFrame(rafId);
+                rafId = null;
+            }
+        }
+        else {
+            lastCurrentTimeReceivedAt = nowMs();
+            rafId = requestAnimationFrame(renderLoop);
+        }
+    }
+};
+const flushQueuedRender = () => {
+    if (renderInFlight || queuedRenders.length === 0)
+        return;
+    if (queuedRenders.length > 1) {
+        const dropped = queuedRenders.length - 1;
+        metrics.framesDropped += dropped;
+        const latest = queuedRenders[queuedRenders.length - 1];
+        queuedRenders.length = 0;
+        queuedRenders.push(latest);
+    }
+    const next = queuedRenders.shift();
+    if (!next)
+        return;
+    render(next.time, next.force);
+};
+const completeRenderCycle = () => {
+    renderInFlight = false;
+    flushQueuedRender();
+};
+const render = (time, force) => {
+    if (renderInFlight) {
+        const queuedItem = { time, force: force ? 1 : 0 };
+        if (queuedItem.force) {
+            queuedRenders.length = 0;
+        }
+        else {
+            const lastQueued = queuedRenders[queuedRenders.length - 1];
+            if (lastQueued && Math.abs(lastQueued.time - queuedItem.time) > 0.25) {
+                queuedRenders.length = 0;
+            }
+        }
+        if (queuedRenders.length >= MAX_QUEUED_RENDERS) {
+            queuedRenders.shift();
+            metrics.framesDropped++;
+        }
+        queuedRenders.push(queuedItem);
+        return;
+    }
+    renderInFlight = true;
+    initPool(); // Ensure pool is ready
+    const times = {};
+    const renderStartTime = performance.now();
+    metrics.renderStartTime = renderStartTime;
+    metrics.pendingRenders++;
+    const api = requireApi();
+    const handle = requireHandle();
+    const forceInt = force ? 1 : 0;
+    // Use the batch render-collect API: single WASM call does render + metadata + image data extraction.
+    ensureRenderCollectBuffer(RENDER_COLLECT_MAX_IMAGES);
+    const written = blendMode === 'wasm'
+        ? api.renderBlendCollect(handle, time, forceInt, rrcBufPtr, rrcBufCapacity)
+        : api.renderImageCollect(handle, time, forceInt, rrcBufPtr, rrcBufCapacity);
+    const headerView = new Int32Array(self.wasmMemory.buffer, rrcBufPtr, RRC_HEADER_INTS);
+    const changed = headerView[0];
+    const imageCount = headerView[1];
+    // Update metrics
+    const renderEndTime = performance.now();
+    const renderDuration = renderEndTime - renderStartTime;
+    metrics.lastRenderTime = renderDuration;
+    metrics.totalRenderTime += renderDuration;
+    metrics.maxRenderTime = Math.max(metrics.maxRenderTime, renderDuration);
+    if (renderDuration > 0) {
+        metrics.minRenderTime = Math.min(metrics.minRenderTime, renderDuration);
+    }
+    if (changed !== 0 || force) {
+        metrics.framesRendered++;
+        metrics.cacheMisses++;
+    }
+    else {
+        metrics.cacheHits++;
+    }
+    if (debug) {
+        const decodeEndTime = performance.now();
+        const renderEndTimeWasm = headerView[2];
+        times.WASMRenderTime = renderEndTimeWasm - renderStartTime;
+        times.WASMBitmapDecodeTime = decodeEndTime - renderEndTimeWasm;
+        times.JSRenderTime = Date.now();
+    }
+    if (changed !== 0 || force) {
+        const images = frameImages;
+        const buffers = frameArrayBuffers;
+        images.length = 0;
+        buffers.length = 0;
+        if (written === 0)
+            return paintImages({ images, buffers, times });
+        const imgDataOffset = rrcBufPtr + RRC_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT;
+        const meta = new Int32Array(self.wasmMemory.buffer, imgDataOffset, written * RRC_IMG_STRIDE);
+        const useAsyncBitmapPath = asyncRender && offscreenRender !== true;
+        if (useAsyncBitmapPath) {
+            const promises = frameBitmapPromises;
+            promises.length = written;
+            for (let i = 0; i < written; ++i) {
+                const metaOffset = i * RRC_IMG_STRIDE;
+                const item = getPooledItem(i);
+                item.x = meta[metaOffset];
+                item.y = meta[metaOffset + 1];
+                item.w = meta[metaOffset + 2];
+                item.h = meta[metaOffset + 3];
+                item.image = 0;
+                const pointer = meta[metaOffset + 4];
+                const byteLength = item.w * item.h * 4;
+                const rawData = new Uint8ClampedArray(self.wasmMemory.buffer, pointer, byteLength);
+                const imageData = new ImageData(rawData, item.w, item.h);
+                promises[i] = asyncRenderOptions
+                    ? createImageBitmap(imageData, { premultiplyAlpha: 'none', colorSpaceConversion: 'none' })
+                    : createImageBitmap(imageData);
+                images[i] = item;
+            }
+            Promise.all(promises).then((bitmaps) => {
+                for (let i = 0; i < written; i++) {
+                    images[i].image = bitmaps[i];
+                }
+                if (debug)
+                    times.JSBitmapGenerationTime = Date.now() - (times.JSRenderTime || 0);
+                paintImages({ images, buffers: bitmaps, times });
+            }).catch(() => {
+                if (asyncRenderOptions) {
+                    asyncRenderOptions = false;
+                    console.warn('[AkariSub] createImageBitmap options not supported, disabling');
+                    metrics.pendingRenders--;
+                    completeRenderCycle();
+                    render(time, force);
+                }
+                else {
+                    metrics.pendingRenders--;
+                    postMessage({ target: 'unbusy' });
+                    completeRenderCycle();
+                }
+            });
+        }
+        else {
+            for (let i = 0; i < written; ++i) {
+                const metaOffset = i * RRC_IMG_STRIDE;
+                const item = getPooledItem(i);
+                item.x = meta[metaOffset];
+                item.y = meta[metaOffset + 1];
+                item.w = meta[metaOffset + 2];
+                item.h = meta[metaOffset + 3];
+                item.image = meta[metaOffset + 4];
+                if (!offCanvasCtx) {
+                    const imagePtr = item.image;
+                    const byteLength = item.w * item.h * 4;
+                    const copiedData = new Uint8ClampedArray(byteLength);
+                    copiedData.set(self.HEAPU8C.subarray(imagePtr, imagePtr + byteLength));
+                    buffers.push(copiedData.buffer);
+                    item.image = copiedData;
+                }
+                images[i] = item;
+            }
+            paintImages({ images, buffers, times });
+        }
+    }
+    else {
+        metrics.pendingRenders--;
+        postMessage({ target: 'unbusy' });
+        completeRenderCycle();
+    }
+};
+self.demand = ({ time }) => {
+    lastCurrentTime = time;
+    lastCurrentTimeReceivedAt = nowMs();
+    const force = forceNextDemandRender ? 1 : 0;
+    forceNextDemandRender = false;
+    render(time, force);
+};
+const renderLoop = (force) => {
+    rafId = null;
+    render(getCurrentTime(), force);
+    if (!_isPaused) {
+        rafId = requestAnimationFrame(renderLoop);
+    }
+};
+const paintImages = ({ times, images, buffers }) => {
+    metrics.pendingRenders--;
+    const width = self.width;
+    const height = self.height;
+    const imageCount = images.length;
+    const resultObject = {
+        target: 'render',
+        asyncRender,
+        images,
+        times,
+        width,
+        height,
+        colorSpace: subtitleColorSpace
+    };
+    if (offscreenRender) {
+        // Only resize canvas when dimensions actually change
+        if (offCanvas.height !== height || offCanvas.width !== width) {
+            offCanvas.width = width;
+            offCanvas.height = height;
+        }
+        offCanvasCtx.clearRect(0, 0, width, height);
+        if (asyncRender) {
+            // Batch draw all images
+            for (let i = 0; i < imageCount; i++) {
+                const img = images[i];
+                if (img.image) {
+                    offCanvasCtx.drawImage(img.image, img.x, img.y);
+                    img.image.close();
+                }
+            }
+        }
+        else {
+            // Non-async path with buffer canvas
+            for (let i = 0; i < imageCount; i++) {
+                const img = images[i];
+                if (img.image) {
+                    const imgW = img.w;
+                    const imgH = img.h;
+                    // Only resize buffer canvas when needed
+                    if (bufferCanvas.width !== imgW || bufferCanvas.height !== imgH) {
+                        bufferCanvas.width = imgW;
+                        bufferCanvas.height = imgH;
+                    }
+                    const pointer = img.image;
+                    const byteLength = imgW * imgH * 4;
+                    const rawData = self.HEAPU8C.subarray(pointer, pointer + byteLength);
+                    bufferCtx.putImageData(new ImageData(rawData, imgW, imgH), 0, 0);
+                    offCanvasCtx.drawImage(bufferCanvas, img.x, img.y);
+                }
+            }
+        }
+        if (offscreenRender === 'hybrid') {
+            if (!imageCount) {
+                postMessage(resultObject);
+                completeRenderCycle();
+                return;
+            }
+            if (debug)
+                times.bitmaps = imageCount;
+            try {
+                const bitmap = offCanvas.transferToImageBitmap();
+                const result = {
+                    ...resultObject,
+                    images: [{ image: bitmap, x: 0, y: 0 }],
+                    asyncRender: true
+                };
+                postMessage(result, [bitmap]);
+                completeRenderCycle();
+            }
+            catch {
+                postMessage({ target: 'unbusy' });
+                completeRenderCycle();
+            }
+        }
+        else {
+            if (debug) {
+                times.JSRenderTime = Date.now() - (times.JSRenderTime || 0) - (times.JSBitmapGenerationTime || 0);
+                let total = 0;
+                for (const key in times)
+                    total += times[key] || 0;
+                console.log('Bitmaps: ' + imageCount + ' Total: ' + (total | 0) + 'ms', times);
+            }
+            postMessage({ target: 'unbusy' });
+            completeRenderCycle();
+        }
+    }
+    else {
+        postMessage(resultObject, buffers);
+        completeRenderCycle();
+    }
+};
+// Custom requestAnimationFrame for worker
+const requestAnimationFrame = self.requestAnimationFrame ? self.requestAnimationFrame.bind(self) : (() => {
+    let nextRAF = 0;
+    return (func) => {
+        const now = nowMs();
+        if (nextRAF === 0) {
+            nextRAF = now + 1000 / targetFps;
+        }
+        else {
+            while (now + 2 >= nextRAF) {
+                nextRAF += 1000 / targetFps;
+            }
+        }
+        const delay = Math.max(nextRAF - now, 0);
+        return setTimeout(func, delay);
+    };
+})();
+const cancelAnimationFrame = self.cancelAnimationFrame ? self.cancelAnimationFrame.bind(self) : clearTimeout;
+// =============================================================================
+// WASM Initialization
+// =============================================================================
+self.init = async (data) => {
+    hasBitmapBug = data.hasBitmapBug;
+    fullTrackWarmupEnabled = !!data.fullTrackWarmup;
+    if (typeof data.initialTime === 'number' && Number.isFinite(data.initialTime)) {
+        lastCurrentTime = data.initialTime;
+    }
+    const _fetch = self.fetch;
+    const setWasmUrl = (wasmUrl) => {
+        if (WebAssembly.instantiateStreaming) {
+            self.fetch = (_) => _fetch(wasmUrl);
+        }
+    };
+    const restoreFetch = () => {
+        self.fetch = _fetch;
+    };
+    const loadWasm = (wasmUrl) => {
+        setWasmUrl(wasmUrl);
+        return WASM({
+            wasm: !WebAssembly.instantiateStreaming ? read_(wasmUrl, true) : undefined
+        }).finally(restoreFetch);
+    };
+    const onWasmLoaded = async (Module) => {
+        _Module = Module; // Store module reference for FS access
+        akariSubApi = {
+            create: Module._akarisub_create,
+            destroy: Module._akarisub_destroy,
+            setDropAnimations: Module._akarisub_set_drop_animations,
+            createTrackMem: Module._akarisub_create_track_mem,
+            removeTrack: Module._akarisub_remove_track,
+            resizeCanvas: Module._akarisub_resize_canvas,
+            addFont: Module._akarisub_add_font,
+            reloadFonts: Module._akarisub_reload_fonts,
+            setDefaultFont: Module._akarisub_set_default_font,
+            setFallbackFonts: Module._akarisub_set_fallback_fonts,
+            setMemoryLimits: Module._akarisub_set_memory_limits,
+            getEventCount: Module._akarisub_get_event_count,
+            allocEvent: Module._akarisub_alloc_event,
+            removeEvent: Module._akarisub_remove_event,
+            getStyleCount: Module._akarisub_get_style_count,
+            allocStyle: Module._akarisub_alloc_style,
+            removeStyle: Module._akarisub_remove_style,
+            styleOverrideIndex: Module._akarisub_style_override_index,
+            disableStyleOverride: Module._akarisub_disable_style_override,
+            getTrackColorSpace: Module._akarisub_get_track_color_space,
+            eventGetInt: Module._akarisub_event_get_int,
+            eventSetInt: Module._akarisub_event_set_int,
+            eventGetStr: Module._akarisub_event_get_str,
+            eventSetStr: Module._akarisub_event_set_str,
+            styleGetNum: Module._akarisub_style_get_num,
+            styleSetNum: Module._akarisub_style_set_num,
+            styleGetStr: Module._akarisub_style_get_str,
+            styleSetStr: Module._akarisub_style_set_str,
+            renderBlendCollect: Module._akarisub_render_blend_collect,
+            renderImageCollect: Module._akarisub_render_image_collect
+        };
+        // Normalize fallback fonts and deduplicate
+        const fallbackFonts = [];
+        const fallbackFontKeys = new Set();
+        if (data.fallbackFonts && data.fallbackFonts.length > 0) {
+            for (const font of data.fallbackFonts) {
+                const originalFont = font.trim();
+                const key = originalFont.toLowerCase();
+                if (key && !fallbackFontKeys.has(key)) {
+                    fallbackFontKeys.add(key);
+                    fallbackFonts.push(originalFont);
+                }
+            }
+        }
+        try {
+            Module.FS_createPath('/', 'fonts', true, true);
+            Module.FS_createPath('/fonts', 'attached', true, true);
+            Module.FS_createPath('/fonts', 'fallback', true, true);
+            Module.FS_createPath('/', 'fontconfig', true, true);
+            Module.FS_createPath('/', 'assets', true, true);
+            Module.FS_createPath('/', 'etc', true, true);
+            Module.FS_createPath('/etc', 'fonts', true, true);
+            const fontsConf = `<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
+<fontconfig>
+        <!-- Font directories listed in priority order -->
+        <dir>/fonts/attached</dir>
+        <dir>/fonts</dir>
+        <dir>/fonts/fallback</dir>
+        <match target="pattern">
+                <test qual="any" name="family">
+                        <string>mono</string>
+                </test>
+                <edit name="family" mode="assign" binding="same">
+                        <string>monospace</string>
+                </edit>
+        </match>
+        <match target="pattern">
+                <test qual="any" name="family">
+                        <string>sans serif</string>
+                </test>
+                <edit name="family" mode="assign" binding="same">
+                        <string>sans-serif</string>
+                </edit>
+        </match>
+        <match target="pattern">
+                <test qual="any" name="family">
+                        <string>sans</string>
+                </test>
+                <edit name="family" mode="assign" binding="same">
+                        <string>sans-serif</string>
+                </edit>
+        </match>
+        <cachedir>/fontconfig</cachedir>
+        <config>
+                <rescan>
+                        <int>0</int>
+                </rescan>
+        </config>
+</fontconfig>
+`;
+            const fontsConfData = TEXT_ENCODER.encode(fontsConf);
+            Module.FS_createDataFile('/assets', 'fonts.conf', fontsConfData, true, false, false);
+            Module.FS_createDataFile('/etc/fonts', 'fonts.conf', fontsConfData, true, false, false);
+        }
+        catch (e) {
+            console.warn('Failed to create font directories or fonts.conf:', e);
+        }
+        self.width = data.width;
+        self.height = data.height;
+        onDemandRenderMode = !!data.onDemandRender;
+        blendMode = data.blendMode;
+        asyncRender = data.asyncRender;
+        if (asyncRender && typeof createImageBitmap === 'undefined') {
+            asyncRender = false;
+            console.error("'createImageBitmap' needed for 'asyncRender' unsupported!");
+        }
+        if (asyncRender) {
+            try {
+                const testCanvas = new OffscreenCanvas(1, 1);
+                const testCtx = testCanvas.getContext('2d');
+                if (testCtx) {
+                    const testData = testCtx.getImageData(0, 0, 1, 1);
+                    await createImageBitmap(testData, { premultiplyAlpha: 'none', colorSpaceConversion: 'none' })
+                        .catch(() => {
+                        asyncRenderOptions = false;
+                        console.warn('[AkariSub] createImageBitmap options not supported (Safari?), rendering without options');
+                    });
+                }
+            }
+            catch {
+                asyncRenderOptions = false;
+            }
+        }
+        availableFonts = data.availableFonts;
+        debug = data.debug;
+        targetFps = data.targetFps || targetFps;
+        useLocalFonts = data.useLocalFonts;
+        dropAllBlur = data.dropAllBlur;
+        clampPos = data.clampPos;
+        // Load fallback fonts asynchronously to avoid blocking worker thread
+        // This is critical for mobile devices where sync XHR can cause timeouts
+        const loadFallbackFontsAsync = async () => {
+            const fontPromises = [];
+            for (const font of fallbackFonts) {
+                const fontLower = font.trim().toLowerCase();
+                const fontKey = fontLower.startsWith('@') ? fontLower.substring(1) : fontLower;
+                if (availableFonts && availableFonts[fontKey]) {
+                    const fontUrl = availableFonts[fontKey];
+                    if (typeof fontUrl === 'string') {
+                        // Async fetch for URL-based fonts
+                        const promise = new Promise((resolve) => {
+                            readAsync(fontUrl, (fontData) => {
+                                writeFontToFSImmediate(new Uint8Array(fontData), true);
+                                fontMap_[fontKey] = true;
+                                if (debug)
+                                    console.log('[AkariSub] Loaded fallback font async:', fontKey);
+                                resolve();
+                            }, (e) => {
+                                console.error('Failed to load fallback font:', fontKey, e);
+                                resolve(); // Don't fail initialization if a single font fails
+                            });
+                        });
+                        fontPromises.push(promise);
+                    }
+                    else {
+                        // Font data directly provided - synchronous write is OK here
+                        writeFontToFSImmediate(fontUrl, true);
+                        fontMap_[fontKey] = true;
+                    }
+                }
+            }
+            // Wait for all fonts to load (with 30s timeout to prevent blocking forever)
+            if (fontPromises.length > 0) {
+                let timeoutId = null;
+                let timedOut = false;
+                const timeoutPromise = new Promise((resolve) => {
+                    timeoutId = setTimeout(() => {
+                        timedOut = true;
+                        console.warn('[AkariSub] Fallback font loading timeout, continuing with available fonts');
+                        resolve();
+                    }, 30000);
+                });
+                await Promise.race([
+                    Promise.all(fontPromises).then(() => {
+                        if (timeoutId !== null)
+                            clearTimeout(timeoutId);
+                    }),
+                    timeoutPromise
+                ]);
+                if (!timedOut && debug) {
+                    console.log('[AkariSub] All fallback fonts loaded successfully');
+                }
+            }
+        };
+        await loadFallbackFontsAsync();
+        const primaryFallback = fallbackFonts.length > 0 ? fallbackFonts[0] : null;
+        akariSubHandle = withCString(primaryFallback || '', (fontPtr) => {
+            return requireApi().create(self.width, self.height, fontPtr, debug ? 1 : 0);
+        });
+        if (pendingFallbackFonts.length > 0) {
+            for (const { data: fontData, name: fontName } of pendingFallbackFonts) {
+                addFontAsEmbedded(fontData, fontName);
+            }
+            pendingFallbackFonts.length = 0;
+            requireApi().reloadFonts(akariSubHandle);
+        }
+        if (fallbackFonts.length > 0) {
+            withCString(fallbackFonts.join(','), (fontsPtr) => {
+                requireApi().setFallbackFonts(requireHandle(), fontsPtr);
+            });
+        }
+        let subContent = data.subContent;
+        let decryptedSubContent = null;
+        if (data.encryptedSubContent) {
+            protectedTrackContent = true;
+            decryptedSubContent = await decryptSubtitleContent(data.encryptedSubContent);
+            subContent = decryptedSubContent;
+        }
+        else {
+            protectedTrackContent = false;
+            if (!subContent)
+                subContent = read_(data.subUrl);
+        }
+        // For large files, emit partial_ready early to allow playback to start
+        // while font loading and track parsing continues in the background
+        const isLargeSubtitle = typeof subContent === 'string'
+            ? subContent.length > 500000
+            : toUint8Array(subContent).byteLength > 500000;
+        if (isLargeSubtitle) {
+            postMessage({ target: 'partial_ready' });
+            if (debug)
+                console.log('[AkariSub] Large subtitle detected, emitting partial_ready early');
+        }
+        if (typeof subContent === 'string') {
+            processAvailableFonts(subContent);
+            if (clampPos)
+                subContent = fixPlayRes(subContent);
+            if (dropAllBlur)
+                subContent = dropBlur(subContent);
+        }
+        else if (debug && (clampPos || dropAllBlur)) {
+            console.warn('[AkariSub] Text rewrite options are skipped for protected binary subtitle content');
+        }
+        // Load attached/preloaded fonts before ready to avoid runtime font churn during first playback.
+        let hasAttachedFonts = false;
+        const attachedFontPromises = [];
+        for (const font of data.fonts || []) {
+            if (typeof font === 'string') {
+                const promise = new Promise((resolve) => {
+                    readAsync(font, (fontData) => {
+                        writeFontToFSImmediate(new Uint8Array(fontData), false);
+                        hasAttachedFonts = true;
+                        if (debug)
+                            console.log('[AkariSub] Loaded attached font async:', font);
+                        resolve();
+                    }, (e) => {
+                        console.error('Failed to load attached font:', font, e);
+                        resolve();
+                    });
+                });
+                attachedFontPromises.push(promise);
+            }
+            else {
+                writeFontToFSImmediate(font, false);
+                hasAttachedFonts = true;
+            }
+        }
+        if (attachedFontPromises.length > 0) {
+            let attachedTimeoutId = null;
+            let attachedTimedOut = false;
+            const attachedTimeoutPromise = new Promise((resolve) => {
+                attachedTimeoutId = setTimeout(() => {
+                    attachedTimedOut = true;
+                    console.warn('[AkariSub] Attached font loading timeout, continuing with available fonts');
+                    resolve();
+                }, 30000);
+            });
+            await Promise.race([
+                Promise.all(attachedFontPromises).then(() => {
+                    if (attachedTimeoutId !== null)
+                        clearTimeout(attachedTimeoutId);
+                }),
+                attachedTimeoutPromise
+            ]);
+            if (!attachedTimedOut && debug) {
+                console.log('[AkariSub] Attached font loading complete');
+            }
+        }
+        if (hasAttachedFonts) {
+            if (debug)
+                console.log('[AkariSub] Reloading fonts after writing attached fonts to FS');
+            requireApi().reloadFonts(requireHandle());
+            if (debug)
+                console.log('[AkariSub] Font reload complete');
+        }
+        if (typeof subContent === 'string') {
+            createTrackFromString(subContent);
+        }
+        else {
+            try {
+                createTrackFromBytes(toUint8Array(subContent));
+            }
+            finally {
+                decryptedSubContent?.fill(0);
+            }
+        }
+        syncTotalEventsMetric();
+        firstTrackEventStartTime = getFirstEventStartTime();
+        subtitleColorSpace = libassYCbCrMap[requireApi().getTrackColorSpace(requireHandle())];
+        requireApi().setDropAnimations(requireHandle(), data.dropAllAnimations || 0);
+        if (data.libassMemoryLimit > 0 || data.libassGlyphLimit > 0) {
+            requireApi().setMemoryLimits(requireHandle(), data.libassGlyphLimit || 0, data.libassMemoryLimit || 0);
+        }
+        initPool();
+        ensureRenderCollectBuffer(PREWARM_MAX_IMAGES);
+        try {
+            prewarmRenderer(lastCurrentTime);
+        }
+        catch (e) {
+            if (debug)
+                console.warn('[AkariSub] Prewarm render failed, continuing:', e);
+        }
+        forceNextDemandRender = true;
+        postMessage({ target: 'ready' });
+        postMessage({ target: 'verifyColorSpace', subtitleColorSpace });
+        scheduleFullTrackWarmup();
+    };
+    loadWasm(data.wasmUrl).then(onWasmLoaded).catch((e) => {
+        console.error('[AkariSub] WASM loading failed:', e);
+        postMessage({ target: 'error', error: 'WASM loading failed: ' + (e && e.message ? e.message : String(e)) });
+    });
+};
+// =============================================================================
+// Canvas Management
+// =============================================================================
+self.offscreenCanvas = ({ transferable }) => {
+    offCanvas = transferable[0];
+    offCanvasCtx = offCanvas.getContext('2d', { desynchronized: true });
+    if (!asyncRender) {
+        bufferCanvas = new OffscreenCanvas(self.width, self.height);
+        bufferCtx = bufferCanvas.getContext('2d', { desynchronized: true });
+    }
+    offscreenRender = true;
+};
+self.detachOffscreen = () => {
+    offCanvas = new OffscreenCanvas(self.width, self.height);
+    offCanvasCtx = offCanvas.getContext('2d', { desynchronized: true });
+    offscreenRender = 'hybrid';
+};
+self.canvas = ({ width, height, videoWidth, videoHeight, force }) => {
+    if (width == null)
+        throw new Error('Invalid canvas size specified');
+    self.width = width;
+    self.height = height;
+    if (akariSubHandle)
+        requireApi().resizeCanvas(akariSubHandle, width, height, videoWidth, videoHeight);
+    if (force)
+        render(lastCurrentTime, true);
+};
+self.video = ({ currentTime, isPaused, rate: newRate }) => {
+    if (currentTime != null)
+        setCurrentTime(currentTime);
+    if (isPaused != null)
+        setIsPaused(isPaused);
+    if (newRate != null)
+        rate = newRate;
+};
+self.destroy = () => {
+    stopWarmup();
+    fullTrackWarmupPromise = null;
+    firstTrackEventStartTime = null;
+    if (_Module) {
+        if (rrcBufPtr) {
+            _Module._free(rrcBufPtr);
+            rrcBufPtr = 0;
+            rrcBufCapacity = 0;
+        }
+    }
+    if (akariSubHandle) {
+        requireApi().destroy(akariSubHandle);
+        akariSubHandle = 0;
+    }
+    metrics.totalEvents = 0;
+};
+self.setAsyncRender = ({ value }) => {
+    asyncRender = value && typeof createImageBitmap !== 'undefined';
+};
+// =============================================================================
+// Event Management
+// =============================================================================
+const applyEventFields = (index, event) => {
+    const api = requireApi();
+    const handle = requireHandle();
+    for (const key of Object.keys(event)) {
+        const value = event[key];
+        if (value == null || key === '_index')
+            continue;
+        if (key in EVENT_INT_FIELDS) {
+            api.eventSetInt(handle, index, EVENT_INT_FIELDS[key], Number(value));
+            continue;
+        }
+        if (key in EVENT_STR_FIELDS) {
+            withCString(String(value), (ptr) => {
+                api.eventSetStr(handle, index, EVENT_STR_FIELDS[key], ptr);
+            });
+        }
+    }
+};
+const readEvent = (index) => {
+    const api = requireApi();
+    const handle = requireHandle();
+    return {
+        Start: api.eventGetInt(handle, index, EVENT_INT_FIELDS.Start),
+        Duration: api.eventGetInt(handle, index, EVENT_INT_FIELDS.Duration),
+        ReadOrder: api.eventGetInt(handle, index, EVENT_INT_FIELDS.ReadOrder),
+        Layer: api.eventGetInt(handle, index, EVENT_INT_FIELDS.Layer),
+        Style: String(api.eventGetInt(handle, index, EVENT_INT_FIELDS.Style)),
+        MarginL: api.eventGetInt(handle, index, EVENT_INT_FIELDS.MarginL),
+        MarginR: api.eventGetInt(handle, index, EVENT_INT_FIELDS.MarginR),
+        MarginV: api.eventGetInt(handle, index, EVENT_INT_FIELDS.MarginV),
+        Name: readCString(api.eventGetStr(handle, index, EVENT_STR_FIELDS.Name)),
+        Text: readCString(api.eventGetStr(handle, index, EVENT_STR_FIELDS.Text)),
+        Effect: readCString(api.eventGetStr(handle, index, EVENT_STR_FIELDS.Effect))
+    };
+};
+const applyStyleFields = (index, style) => {
+    const api = requireApi();
+    const handle = requireHandle();
+    for (const key of Object.keys(style)) {
+        const value = style[key];
+        if (value == null)
+            continue;
+        if (key in STYLE_NUM_FIELDS) {
+            api.styleSetNum(handle, index, STYLE_NUM_FIELDS[key], Number(value));
+            continue;
+        }
+        if (key in STYLE_STR_FIELDS) {
+            withCString(String(value), (ptr) => {
+                api.styleSetStr(handle, index, STYLE_STR_FIELDS[key], ptr);
+            });
+        }
+    }
+};
+const readStyle = (index) => {
+    const api = requireApi();
+    const handle = requireHandle();
+    return {
+        Name: readCString(api.styleGetStr(handle, index, STYLE_STR_FIELDS.Name)),
+        FontName: readCString(api.styleGetStr(handle, index, STYLE_STR_FIELDS.FontName)),
+        FontSize: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.FontSize),
+        PrimaryColour: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.PrimaryColour),
+        SecondaryColour: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.SecondaryColour),
+        OutlineColour: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.OutlineColour),
+        BackColour: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.BackColour),
+        Bold: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Bold),
+        Italic: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Italic),
+        Underline: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Underline),
+        StrikeOut: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.StrikeOut),
+        ScaleX: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.ScaleX),
+        ScaleY: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.ScaleY),
+        Spacing: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Spacing),
+        Angle: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Angle),
+        BorderStyle: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.BorderStyle),
+        Outline: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Outline),
+        Shadow: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Shadow),
+        Alignment: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Alignment),
+        MarginL: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.MarginL),
+        MarginR: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.MarginR),
+        MarginV: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.MarginV),
+        Encoding: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Encoding),
+        treat_fontname_as_pattern: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.treat_fontname_as_pattern),
+        Blur: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Blur),
+        Justify: api.styleGetNum(handle, index, STYLE_NUM_FIELDS.Justify)
+    };
+};
+self.createEvent = ({ event }) => {
+    const index = requireApi().allocEvent(requireHandle());
+    if (index >= 0)
+        applyEventFields(index, event);
+    syncTotalEventsMetric();
+};
+self.getEvents = () => {
+    const events = [];
+    const api = requireApi();
+    const count = api.getEventCount(requireHandle());
+    for (let i = 0; i < count; i++) {
+        const event = { ...readEvent(i), _index: i };
+        if (protectedTrackContent) {
+            event.Name = '';
+            event.Effect = '';
+            event.Text = '';
+        }
+        events.push(event);
+    }
+    postMessage({ target: 'getEvents', events });
+};
+self.setEvent = ({ event, index }) => {
+    applyEventFields(index, event);
+};
+self.removeEvent = ({ index }) => {
+    requireApi().removeEvent(requireHandle(), index);
+    syncTotalEventsMetric();
+};
+// =============================================================================
+// Style Management
+// =============================================================================
+self.createStyle = ({ style }) => {
+    const index = requireApi().allocStyle(requireHandle());
+    if (index >= 0)
+        applyStyleFields(index, style);
+    return index;
+};
+self.getStyles = () => {
+    const styles = [];
+    const api = requireApi();
+    const count = api.getStyleCount(requireHandle());
+    for (let i = 0; i < count; i++) {
+        styles.push(readStyle(i));
+    }
+    postMessage({ target: 'getStyles', time: Date.now(), styles });
+};
+self.setStyle = ({ style, index }) => {
+    applyStyleFields(index, style);
+};
+self.removeStyle = ({ index }) => {
+    requireApi().removeStyle(requireHandle(), index);
+};
+self.styleOverride = (data) => {
+    const index = self.createStyle(data);
+    if (typeof index === 'number' && index >= 0) {
+        requireApi().styleOverrideIndex(requireHandle(), index);
+    }
+};
+self.disableStyleOverride = () => {
+    requireApi().disableStyleOverride(requireHandle());
+};
+self.defaultFont = ({ font }) => {
+    withCString(font, (fontPtr) => {
+        requireApi().setDefaultFont(requireHandle(), fontPtr);
+    });
+};
+// =============================================================================
+// Performance Metrics
+// =============================================================================
+self.getStats = () => {
+    const avgRenderTime = metrics.framesRendered > 0 ? metrics.totalRenderTime / metrics.framesRendered : 0;
+    postMessage({
+        target: 'getStats',
+        stats: {
+            framesRendered: metrics.framesRendered,
+            framesDropped: metrics.framesDropped,
+            avgRenderTime: Math.round(avgRenderTime * 100) / 100,
+            maxRenderTime: Math.round(metrics.maxRenderTime * 100) / 100,
+            minRenderTime: metrics.minRenderTime === Infinity ? 0 : Math.round(metrics.minRenderTime * 100) / 100,
+            lastRenderTime: Math.round(metrics.lastRenderTime * 100) / 100,
+            pendingRenders: Math.max(0, metrics.pendingRenders),
+            totalEvents: metrics.totalEvents,
+            cacheHits: metrics.cacheHits,
+            cacheMisses: metrics.cacheMisses
+        }
+    });
+};
+self.resetStats = () => {
+    resetMetrics();
+    postMessage({ target: 'resetStats', success: true });
+};
+self.getEventCount = () => {
+    const count = akariSubHandle ? requireApi().getEventCount(akariSubHandle) : 0;
+    postMessage({ target: 'getEventCount', count });
+};
+self.getStyleCount = () => {
+    const count = akariSubHandle ? requireApi().getStyleCount(akariSubHandle) : 0;
+    postMessage({ target: 'getStyleCount', count });
+};
+// =============================================================================
+// Message Handler
+// =============================================================================
+onmessage = ({ data }) => {
+    if (!self[data.target]) {
+        throw new Error('Unknown event target ' + data.target);
+    }
+    Promise.resolve(self[data.target](data)).catch((error) => {
+        postMessage({
+            target: 'error',
+            error: error instanceof Error ? error.message : String(error)
+        });
+    });
+};
+//# sourceMappingURL=worker.js.map