eb-player 2.0.12 → 2.0.14

package/dist/build/ebplayer-engines.bundle.js

@@ -1,2393 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.EBPlayerEngines = {}));
-})(this, (function (exports) { 'use strict';
-
-    /**
-     * EngineStateSync is the abstract base class defining the contract for Phase 2
-     * engine bridge implementations (HLS, DASH).
-     *
-     * Phase 2 HLS and DASH engines extend this class to bridge DOM video events
-     * to the PlayerState store. The attach() method receives the PlayerState and
-     * an AbortSignal for automatic cleanup — engines register video element
-     * event listeners using the signal to ensure zero-leak cleanup on dispose().
-     *
-     * Usage pattern in Phase 2:
-     *   class HlsEngineSync extends EngineStateSync {
-     *     attach(state: PlayerState, signal: AbortSignal): void {
-     *       video.addEventListener('timeupdate', () => { state.currentTime = video.currentTime }, { signal })
-     *     }
-     *     detach(): void {
-     *       this.driver?.destroy()
-     *     }
-     *   }
-     */
-    class EngineStateSync {
-    }
-
-    /**
-     * StallWatchdog - Automatic playback recovery for live streams.
-     *
-     * Detects silent stalls (video.currentTime not advancing) and escalates
-     * through recovery attempts before requesting a full stream reload.
-     *
-     * Ported from component/engines/common.js:
-     *   startStallWatchdog / stopStallWatchdog / recoverFromStall
-     *
-     * Escalation sequence (10s interval):
-     *   - Attempt 1 (10s stuck): calls onRecoverAttempt(1)
-     *   - Attempt 2 (20s stuck): calls onRecoverAttempt(2)
-     *   - Attempt 3 (30s stuck): calls onReloadRequired(), stops watchdog
-     */
-    class StallWatchdog {
-        constructor(options) {
-            this.intervalId = null;
-            this.lastTime = null;
-            this.stallAttempts = 0;
-            this.video = options.video;
-            this.onRecoverAttempt = options.onRecoverAttempt;
-            this.onReloadRequired = options.onReloadRequired;
-            this.isCasting = options.isCasting;
-        }
-        /**
-         * Start the stall watchdog interval.
-         * Calls stop() first to ensure idempotent restart.
-         */
-        start() {
-            this.stop();
-            this.intervalId = setInterval(() => {
-                this.tick();
-            }, 10000);
-        }
-        /**
-         * Stop the stall watchdog and reset all internal state.
-         */
-        stop() {
-            if (this.intervalId !== null) {
-                clearInterval(this.intervalId);
-                this.intervalId = null;
-            }
-            this.lastTime = null;
-            this.stallAttempts = 0;
-        }
-        tick() {
-            // Skip check when paused or casting
-            if (this.video.paused || this.isCasting()) {
-                this.lastTime = null;
-                return;
-            }
-            const currentTime = this.video.currentTime;
-            if (this.lastTime !== null && currentTime === this.lastTime) {
-                // currentTime not advancing — stall detected
-                this.stallAttempts += 1;
-                if (this.stallAttempts <= 2) {
-                    this.onRecoverAttempt(this.stallAttempts);
-                }
-                else {
-                    this.onReloadRequired();
-                    this.stop();
-                }
-            }
-            else {
-                // currentTime advanced (or first tick) — reset stall counter
-                this.stallAttempts = 0;
-                this.lastTime = currentTime;
-            }
-        }
-    }
-
-    /**
-     * BaseEngine — abstract base class for HLS and DASH engine implementations.
-     *
-     * Extends EngineStateSync with concrete lifecycle management:
-     *   - stores video, state, signal, bus, config
-     *   - binds native video element events to PlayerState
-     *   - delegates engine-specific startup / teardown to onAttach / onDetach
-     *   - delegates stall recovery to recoverFromStall (engine-specific)
-     */
-    class BaseEngine extends EngineStateSync {
-        constructor() {
-            super(...arguments);
-            this.video = null;
-            this.state = null;
-            this.signal = null;
-            this.bus = null;
-            this.config = null;
-            this.watchdog = null;
-        }
-        // -------------------------------------------------------------------------
-        // EngineStateSync contract
-        // -------------------------------------------------------------------------
-        attach(state, signal) {
-            this.state = state;
-            this.signal = signal;
-            void this.onAttach();
-        }
-        detach() {
-            this.watchdog?.stop();
-            this.watchdog = null;
-            this.onDetach();
-            this.video = null;
-            this.state = null;
-            this.signal = null;
-            this.bus = null;
-            this.config = null;
-        }
-        // -------------------------------------------------------------------------
-        // Stall watchdog helpers
-        // -------------------------------------------------------------------------
-        startWatchdog() {
-            if (!this.video || !this.bus)
-                return;
-            const busRef = this.bus;
-            this.watchdog = new StallWatchdog({
-                video: this.video,
-                onRecoverAttempt: (attempt) => {
-                    this.recoverFromStall(attempt);
-                },
-                onReloadRequired: () => {
-                    busRef.emit('request-reload');
-                },
-                isCasting: () => {
-                    return this.state?.isCasting ?? false;
-                }
-            });
-            this.watchdog.start();
-        }
-        stopWatchdog() {
-            this.watchdog?.stop();
-            this.watchdog = null;
-        }
-        // -------------------------------------------------------------------------
-        // Video element event binding
-        // -------------------------------------------------------------------------
-        // -------------------------------------------------------------------------
-        // Public setters — used by factory/test code before attach()
-        // -------------------------------------------------------------------------
-        setConfig(config) {
-            this.config = config;
-        }
-        setBus(bus) {
-            this.bus = bus;
-        }
-        setVideo(video) {
-            this.video = video;
-        }
-        // -------------------------------------------------------------------------
-        // Video element event binding
-        // -------------------------------------------------------------------------
-        bindVideoEvents(video, state, signal) {
-            // Playback timing
-            video.addEventListener('timeupdate', () => {
-                state.currentTime = Math.round(video.currentTime);
-            }, { signal });
-            video.addEventListener('durationchange', () => {
-                state.duration = Math.ceil(video.duration);
-            }, { signal });
-            // Volume / mute
-            video.addEventListener('volumechange', () => {
-                state.volume = video.volume;
-                state.muted = video.muted;
-            }, { signal });
-            // Buffer progress
-            video.addEventListener('progress', () => {
-                if (video.buffered.length > 0) {
-                    state.bufferedEnd = video.buffered.end(video.buffered.length - 1);
-                }
-            }, { signal });
-            // Playback rate
-            video.addEventListener('ratechange', () => {
-                state.playbackRate = video.playbackRate;
-            }, { signal });
-            // FSM transitions: playing, pause, waiting, ended
-            video.addEventListener('playing', () => {
-                state.playbackState = 'playing';
-            }, { signal });
-            video.addEventListener('pause', () => {
-                state.playbackState = 'paused';
-            }, { signal });
-            video.addEventListener('waiting', () => {
-                state.playbackState = 'buffering';
-            }, { signal });
-            video.addEventListener('ended', () => {
-                state.playbackState = 'ended';
-            }, { signal });
-        }
-    }
-
-    /**
-     * CDN Script Loader
-     *
-     * Replaces the scriptjs-based component/utils/load.js with direct <script> tag injection.
-     * Resolves with window[globalName] when the script loads, or rejects with a clear error.
-     */
-    /**
-     * Loads a CDN script by injecting a <script> tag into document.head and resolves
-     * with window[globalName] once the script has loaded.
-     *
-     * - If window[globalName] already exists, resolves immediately (no re-injection).
-     * - If the script loads but the global is not on window, rejects with a descriptive error.
-     * - If script.onerror fires, rejects with a descriptive error.
-     * - If neither onload nor onerror fires within `options.timeout` ms (default 10000), rejects.
-     */
-    function loadScript(url, globalName, options = {}) {
-        const windowRecord = window;
-        if (windowRecord[globalName] !== undefined) {
-            return Promise.resolve(windowRecord[globalName]);
-        }
-        const timeoutMs = options.timeout ?? 10000;
-        return new Promise((resolve, reject) => {
-            let timeoutHandle;
-            const cleanup = () => {
-                clearTimeout(timeoutHandle);
-            };
-            const script = document.createElement('script');
-            script.src = url;
-            script.onload = () => {
-                cleanup();
-                const lib = windowRecord[globalName];
-                if (lib === undefined) {
-                    reject(new Error(`CDN: '${globalName}' not on window after loading ${url}`));
-                }
-                else {
-                    resolve(lib);
-                }
-            };
-            script.onerror = () => {
-                cleanup();
-                reject(new Error(`CDN: failed to load ${url}`));
-            };
-            timeoutHandle = setTimeout(() => {
-                reject(new Error(`CDN: timeout loading ${url}`));
-            }, timeoutMs);
-            document.head.appendChild(script);
-        });
-    }
-
-    /**
-     * CDN Token Manager
-     *
-     * TypeScript port of component/utils/token.js (CDNTokenManager class, 459 LOC).
-     * Supports four token flows: default (Cloudflare query params), easybroadcast/venom
-     * (EasyBroadcast format via POST), akamai (path-segment format), and bunny (POST JSON).
-     *
-     * All sub-types (TokenError, TokenResponse, ResponseParameters) are inlined here
-     * since they are only used by CDNTokenManager.
-     */
-    // ---------------------------------------------------------------------------
-    // Token type constants
-    // ---------------------------------------------------------------------------
-    const TOKEN_TYPES = Object.freeze({
-        EASY_B: 'easy_b',
-        BUNNY: 'bunny',
-        AKAMAI: 'akamai',
-        VENOM: 'venom'
-    });
-    // ---------------------------------------------------------------------------
-    // Error types
-    // ---------------------------------------------------------------------------
-    const ERROR_TYPES = Object.freeze({
-        UNKNOWN: 'unknown',
-        MAX_RETRY: 'max_retry',
-        FORBIDDEN: 'forbidden'
-    });
-    class TokenError extends Error {
-        constructor({ status = 'unknown', errorCode = 'unknown', errorType = ERROR_TYPES.UNKNOWN, message = null }) {
-            super(message ?? `TokenError: ${status} - ${errorCode}`);
-            this.status = status;
-            this.errorCode = errorCode;
-            this.errorType = errorType;
-        }
-    }
-    class TokenResponse {
-        constructor({ src, responseParameters, error = null, extras = {} }) {
-            this.src = src;
-            this.responseParameters = responseParameters;
-            this.extras = extras ?? {};
-            if (error !== null && !(error instanceof TokenError)) {
-                throw new Error('TokenResponse error must be an instance of TokenError');
-            }
-            this.error = error;
-        }
-        static fromJson({ src, json }) {
-            const obj = JSON.parse(json);
-            const responseParameters = {
-                token: obj.token ?? null,
-                tokenPath: obj.token_path ?? null,
-                expires: obj.expires ?? null
-            };
-            const tokenResponse = new TokenResponse({ src, responseParameters });
-            // Copy extra properties (e.g. drm_custom_data)
-            for (const key of Object.keys(obj)) {
-                if (!['token', 'expires', 'token_path'].includes(key)) {
-                    tokenResponse.extras[key] = obj[key];
-                }
-            }
-            return tokenResponse;
-        }
-        static fromAkamai({ src, text }) {
-            const responseParameters = parseAkamaiResponse({ src, text });
-            return new TokenResponse({ src, responseParameters });
-        }
-        static fromText({ src, text }) {
-            if (text.trim().startsWith('{')) {
-                return TokenResponse.fromJson({ src, json: text });
-            }
-            const params = new URLSearchParams(text.trim().replace(/^\?/, ''));
-            const token = params.get('token') ?? null;
-            const expiresStr = params.get('expires');
-            const expires = expiresStr ? parseInt(expiresStr, 10) : null;
-            const tokenPath = params.get('token_path') ?? null;
-            const responseParameters = { token, tokenPath, expires };
-            const tokenResponse = new TokenResponse({ src, responseParameters });
-            params.forEach((value, key) => {
-                if (!['token', 'expires', 'token_path'].includes(key)) {
-                    tokenResponse.extras[key] = value;
-                }
-            });
-            return tokenResponse;
-        }
-        static fromDefault({ src, text }) {
-            const params = new URLSearchParams(text.trim().replace(/^\?/, ''));
-            const expiresStr = params.get('expires');
-            const responseParameters = {
-                verify: params.get('verify') ?? null,
-                expires: expiresStr ? parseInt(expiresStr, 10) : null
-            };
-            const tokenResponse = new TokenResponse({ src, responseParameters });
-            params.forEach((value, key) => {
-                if (!['verify', 'expires'].includes(key)) {
-                    tokenResponse.extras[key] = value;
-                }
-            });
-            return tokenResponse;
-        }
-        static fromError({ src, error }) {
-            const tokenError = error instanceof TokenError ? error : new TokenError(error);
-            return new TokenResponse({ src, error: tokenError });
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Akamai response parameter parsing (inlined from CDNtoken/akamaiResponseParameters.js)
-    // ---------------------------------------------------------------------------
-    function parseAkamaiResponse({ src, text }) {
-        const fullUrl = `${src}${text ? `?${text}` : ''}`;
-        const srcUrl = new URL(fullUrl);
-        let hdntl = null;
-        let exp = null;
-        let hmac = null;
-        let acl = null;
-        let hdnea = null;
-        const params = new URLSearchParams(srcUrl.search);
-        hdntl = params.get('hdntl');
-        hdnea = params.get('hdnea');
-        if (!hdntl && !hdnea) {
-            const pathSegments = srcUrl.pathname.split('/');
-            for (const segment of pathSegments) {
-                if (segment.startsWith('hdntl=')) {
-                    hdntl = segment.substring(6);
-                    break;
-                }
-                else if (segment.startsWith('hdnea=')) {
-                    hdnea = segment.substring(6);
-                    break;
-                }
-            }
-        }
-        const tokenValue = hdntl ?? hdnea;
-        if (tokenValue) {
-            const expMatch = tokenValue.match(/exp=(\d+)/);
-            if (expMatch)
-                exp = expMatch[1];
-            const hmacMatch = tokenValue.match(/hmac=([a-f0-9]+)/);
-            if (hmacMatch)
-                hmac = hmacMatch[1];
-            const aclMatch = tokenValue.match(/acl=([^~]+)/);
-            if (aclMatch)
-                acl = aclMatch[1];
-        }
-        return { expires: exp, hdntl: tokenValue, hmac, acl, hdnea };
-    }
-    // ---------------------------------------------------------------------------
-    // Internal wait helper
-    // ---------------------------------------------------------------------------
-    function wait(ms) {
-        return new Promise((resolve) => { setTimeout(resolve, ms); });
-    }
-    // ---------------------------------------------------------------------------
-    // CDNTokenManager
-    // ---------------------------------------------------------------------------
-    class CDNTokenManager {
-        constructor({ token, tokenType, srcInTokenRequest = false, extraParamsCallback = null, onCDNTokenError, maxRetries = 3, retryInterval = 10000, expirationMarginInSeconds = 30 }) {
-            const validTypes = Object.values(TOKEN_TYPES);
-            if (tokenType !== undefined && validTypes.includes(tokenType)) {
-                this.tokenType = tokenType;
-            }
-            else {
-                this.tokenType = undefined;
-            }
-            this.tokenGeneratorUrl = token;
-            this.srcInTokenRequest = srcInTokenRequest;
-            if (extraParamsCallback && typeof extraParamsCallback === 'function') {
-                this.extraParamsCallback = extraParamsCallback;
-            }
-            else {
-                this.extraParamsCallback = null;
-            }
-            if (onCDNTokenError && typeof onCDNTokenError === 'function') {
-                this.callbackError = onCDNTokenError;
-            }
-            else {
-                this.callbackError = null;
-            }
-            this.attempt = 0;
-            this.maxRetries = maxRetries;
-            this.retryInterval = retryInterval;
-            this.expirationMarginInSeconds = expirationMarginInSeconds;
-            this.lastTokenResponse = null;
-            this.resetAttemptCounterTimeout = null;
-        }
-        resetAttemptCounter() {
-            if (this.resetAttemptCounterTimeout) {
-                return;
-            }
-            this.resetAttemptCounterTimeout = setTimeout(() => {
-                this.attempt = 0;
-            }, 30000);
-        }
-        // -------------------------------------------------------------------------
-        // Default flow (Cloudflare / generic query params)
-        // -------------------------------------------------------------------------
-        async _fetchDefaultToken(src, lastHttpResponse = null) {
-            const srcUrl = new URL(src);
-            ['verify', 'expires'].forEach((param) => srcUrl.searchParams.delete(param));
-            if (this.attempt >= this.maxRetries) {
-                this.resetAttemptCounter();
-                return TokenResponse.fromError({
-                    src: srcUrl.toString(),
-                    error: new TokenError({
-                        status: lastHttpResponse?.status,
-                        errorCode: 'Unauthorized',
-                        errorType: ERROR_TYPES.MAX_RETRY
-                    })
-                });
-            }
-            try {
-                this.attempt += 1;
-                let response;
-                if (this.srcInTokenRequest === true) {
-                    response = await fetch(`${this.tokenGeneratorUrl}?url=${encodeURIComponent(srcUrl.toString())}`);
-                }
-                else {
-                    response = await fetch(this.tokenGeneratorUrl);
-                }
-                if (response.status === 403) {
-                    await wait(this.retryInterval);
-                    return this._fetchDefaultToken(src, response);
-                }
-                if (response.status >= 400) {
-                    return TokenResponse.fromError({
-                        src: srcUrl.toString(),
-                        error: new TokenError({ status: response.status })
-                    });
-                }
-                this.attempt = 0;
-                const responseText = await response.text();
-                return TokenResponse.fromDefault({ src: srcUrl.toString(), text: responseText });
-            }
-            catch (error) {
-                console.error('CDNToken: Error fetching default token ', error);
-                return TokenResponse.fromError({
-                    src: srcUrl.toString(),
-                    error: error
-                });
-            }
-        }
-        // -------------------------------------------------------------------------
-        // EasyBroadcast / Venom flow
-        // -------------------------------------------------------------------------
-        async _fetchEasyBToken(src, lastHttpResponse = null) {
-            if (this.attempt >= this.maxRetries) {
-                this.resetAttemptCounter();
-                return TokenResponse.fromError({
-                    src,
-                    error: new TokenError({
-                        status: lastHttpResponse?.error?.status,
-                        errorCode: (lastHttpResponse?.error?.errorCode) ?? 'Unauthorized',
-                        errorType: ERROR_TYPES.MAX_RETRY
-                    })
-                });
-            }
-            try {
-                this.attempt += 1;
-                const headers = {};
-                if (this.extraParamsCallback) {
-                    const extraParams = await this.extraParamsCallback(lastHttpResponse?.error?.status);
-                    if (extraParams?.accessToken) {
-                        headers.Authorization = `Bearer ${String(extraParams.accessToken)}`;
-                    }
-                }
-                else {
-                    console.warn('CDNToken: no extraParamsCallback provided');
-                }
-                let response;
-                if (this.srcInTokenRequest === true) {
-                    response = await fetch(`${this.tokenGeneratorUrl}?url=${encodeURIComponent(src)}`, {
-                        method: 'GET',
-                        headers
-                    });
-                }
-                else {
-                    response = await fetch(this.tokenGeneratorUrl, {
-                        method: 'POST',
-                        headers,
-                        body: JSON.stringify({ streamUrl: src })
-                    });
-                }
-                if (response.status >= 400) {
-                    const tokenResponse = TokenResponse.fromError({
-                        src,
-                        error: new TokenError({ status: response.status })
-                    });
-                    if (response.status === 403) {
-                        await wait(this.retryInterval);
-                        return this._fetchEasyBToken(src, tokenResponse);
-                    }
-                    return tokenResponse;
-                }
-                this.attempt = 0;
-                const responseText = await response.text();
-                return TokenResponse.fromText({ src, text: responseText });
-            }
-            catch (error) {
-                console.error('CDNToken: Error fetching token ', error);
-                return TokenResponse.fromError({ src, error: error });
-            }
-        }
-        // -------------------------------------------------------------------------
-        // Akamai flow
-        // -------------------------------------------------------------------------
-        async _fetchAkamaiToken(src, lastHttpResponse = null) {
-            if (this.attempt >= this.maxRetries) {
-                this.resetAttemptCounter();
-                return TokenResponse.fromError({
-                    src,
-                    error: new TokenError({
-                        status: lastHttpResponse?.status,
-                        errorCode: 'Unauthorized',
-                        errorType: ERROR_TYPES.MAX_RETRY
-                    })
-                });
-            }
-            try {
-                this.attempt += 1;
-                const response = await fetch(`${this.tokenGeneratorUrl}?url=${encodeURIComponent(src)}`);
-                if (response.status === 403) {
-                    await wait(this.retryInterval);
-                    return this._fetchAkamaiToken(src, response);
-                }
-                if (response.status >= 400) {
-                    return TokenResponse.fromError({
-                        src,
-                        error: new TokenError({ status: response.status })
-                    });
-                }
-                this.attempt = 0;
-                const responseText = await response.text();
-                return TokenResponse.fromAkamai({ src, text: responseText });
-            }
-            catch (error) {
-                console.error('CDNToken: Error fetching token ', error);
-                return TokenResponse.fromError({ src, error: error });
-            }
-        }
-        // -------------------------------------------------------------------------
-        // Bunny CDN flow
-        // -------------------------------------------------------------------------
-        async _fetchBunnyToken(src, tokenResponse = null) {
-            if (this.attempt >= this.maxRetries) {
-                this.resetAttemptCounter();
-                return TokenResponse.fromError({
-                    src,
-                    error: new TokenError({
-                        status: tokenResponse?.error?.status,
-                        errorCode: (tokenResponse?.error?.errorCode) ?? 'Unauthorized',
-                        errorType: ERROR_TYPES.MAX_RETRY
-                    })
-                });
-            }
-            try {
-                this.attempt += 1;
-                const headers = {
-                    'Content-Type': 'application/json'
-                };
-                if (this.extraParamsCallback) {
-                    const extraParams = await this.extraParamsCallback(tokenResponse?.error?.status);
-                    if (extraParams?.accessToken) {
-                        headers.Authorization = `Bearer ${String(extraParams.accessToken)}`;
-                    }
-                }
-                else {
-                    console.warn('CDNToken: no extraParamsCallback provided');
-                }
-                const response = await fetch(this.tokenGeneratorUrl, {
-                    method: 'POST',
-                    headers,
-                    body: JSON.stringify({ streamUrl: src })
-                });
-                if (response.status >= 400) {
-                    const contentType = response.headers.get('content-type');
-                    const result = contentType?.includes('application/json')
-                        ? await response.json()
-                        : await response.text();
-                    const errorCode = typeof result === 'object' && result !== null
-                        ? result.error?.errorCode ?? 'Unauthorized'
-                        : 'Unauthorized';
-                    const errorType = typeof result === 'object' && result !== null
-                        ? result.error?.__type ?? ERROR_TYPES.UNKNOWN
-                        : ERROR_TYPES.UNKNOWN;
-                    const tokenError = new TokenError({ status: response.status, errorCode, errorType });
-                    const errorResponse = TokenResponse.fromError({ src, error: tokenError });
-                    if ([403, 401, 498].includes(response.status)) {
-                        if (this.callbackError) {
-                            this.callbackError({
-                                status: tokenError.status,
-                                errorCode: tokenError.errorCode,
-                                errorType: tokenError.errorType
-                            });
-                        }
-                        else {
-                            console.warn(`CDNToken: Bunny token fetch attempt ${this.attempt} for ${src} failed with status ${response.status}, retrying in ${this.retryInterval / 1000}s`);
-                        }
-                        await wait(this.retryInterval);
-                        return this._fetchBunnyToken(src, errorResponse);
-                    }
-                    console.error(`CDNToken: error generating Bunny token on attempt ${this.attempt}`, JSON.stringify(errorResponse));
-                    return errorResponse;
-                }
-                // Success
-                const jsonResponse = await response.json();
-                this.attempt = 0;
-                if (Number.isInteger(jsonResponse.max_retries) && jsonResponse.max_retries > 0) {
-                    this.maxRetries = jsonResponse.max_retries;
-                }
-                if (Number.isInteger(jsonResponse.retry_interval) && jsonResponse.retry_interval > 0) {
-                    this.retryInterval = jsonResponse.retry_interval * 1000;
-                }
-                return TokenResponse.fromJson({ src, json: JSON.stringify(jsonResponse) });
-            }
-            catch (error) {
-                console.error('CDNToken: Error fetching bunny token:', error);
-                return TokenResponse.fromError({ src, error: error });
-            }
-        }
-        // -------------------------------------------------------------------------
-        // Public: fetchToken
-        // -------------------------------------------------------------------------
-        async fetchToken({ src }) {
-            if (!src) {
-                console.warn('CDNToken: Missing src to tokenize');
-                return null;
-            }
-            switch (this.tokenType) {
-                case TOKEN_TYPES.BUNNY:
-                    this.lastTokenResponse = await this._fetchBunnyToken(src);
-                    break;
-                case TOKEN_TYPES.AKAMAI:
-                    this.lastTokenResponse = await this._fetchAkamaiToken(src);
-                    break;
-                case TOKEN_TYPES.VENOM:
-                case TOKEN_TYPES.EASY_B:
-                    this.lastTokenResponse = await this._fetchEasyBToken(src);
-                    break;
-                default:
-                    this.lastTokenResponse = await this._fetchDefaultToken(src);
-            }
-            return this.lastTokenResponse;
-        }
-        // -------------------------------------------------------------------------
-        // Public: updateUrlWithTokenParams
-        // -------------------------------------------------------------------------
-        async updateUrlWithTokenParams({ url }) {
-            const srcUrl = new URL(url);
-            const expires = srcUrl.searchParams.get('expires');
-            switch (this.tokenType) {
-                case TOKEN_TYPES.AKAMAI: {
-                    const akamaiParams = parseAkamaiResponse({ src: url, text: '' });
-                    if (!this.isTokenExpired(akamaiParams.expires)) {
-                        return url;
-                    }
-                    // Remove hdntl / hdnea path segments before requesting new token
-                    const pathSegments = srcUrl.pathname.split('/');
-                    srcUrl.pathname = pathSegments
-                        .filter((segment) => !segment.startsWith('hdntl=') && !segment.startsWith('hdnea='))
-                        .join('/');
-                    break;
-                }
-                case TOKEN_TYPES.EASY_B:
-                case TOKEN_TYPES.VENOM:
-                case TOKEN_TYPES.BUNNY: {
-                    if (!this.isTokenExpired(expires)) {
-                        return url;
-                    }
-                    ['token', 'expires', 'token_path'].forEach((param) => srcUrl.searchParams.delete(param));
-                    // Reuse cached lastTokenResponse if still valid
-                    const cachedResponse = this.lastTokenResponse;
-                    if (cachedResponse) {
-                        const cachedParams = cachedResponse.responseParameters;
-                        if (cachedParams && !this.isTokenExpired(cachedParams.expires)) {
-                            const { token, expires: cachedExpires, tokenPath } = cachedParams;
-                            return CDNTokenManager.appendTokenParams(url, token, cachedExpires, tokenPath);
-                        }
-                    }
-                    break;
-                }
-                default:
-                    if (!this.isTokenExpired(expires)) {
-                        return url;
-                    }
-                    break;
-            }
-            try {
-                const tokenResponse = await this.fetchToken({ src: srcUrl.toString() });
-                if (tokenResponse === null) {
-                    return url;
-                }
-                if (tokenResponse.error) {
-                    if (this.callbackError) {
-                        this.callbackError({
-                            status: tokenResponse.error.status,
-                            errorCode: tokenResponse.error.errorCode,
-                            errorType: tokenResponse.error.errorType
-                        });
-                    }
-                    return url;
-                }
-                switch (this.tokenType) {
-                    case TOKEN_TYPES.BUNNY:
-                    case TOKEN_TYPES.VENOM:
-                    case TOKEN_TYPES.EASY_B: {
-                        const params = tokenResponse.responseParameters;
-                        return CDNTokenManager.appendTokenParams(url, params.token, params.expires, params.tokenPath);
-                    }
-                    case TOKEN_TYPES.AKAMAI: {
-                        const params = tokenResponse.responseParameters;
-                        return CDNTokenManager.appendAkamaiTokenParams(url, params.hdntl ?? params.hdnea ?? '');
-                    }
-                    default: {
-                        return CDNTokenManager.appendDefaultTokenParams(url, tokenResponse);
-                    }
-                }
-            }
-            catch (error) {
-                console.error('CDNToken: Error while fetching new token:', error);
-                return url;
-            }
-        }
-        // -------------------------------------------------------------------------
-        // Public: isTokenExpired
-        // -------------------------------------------------------------------------
-        isTokenExpired(expirationTime) {
-            if (expirationTime === null || expirationTime === undefined)
-                return true;
-            const currentTimeInSeconds = Math.floor(Date.now() / 1000) + this.expirationMarginInSeconds;
-            if (Number(expirationTime) < currentTimeInSeconds) {
-                return true;
-            }
-            return false;
-        }
-        // -------------------------------------------------------------------------
-        // Public: destroy
-        // -------------------------------------------------------------------------
-        destroy() {
-            if (this.resetAttemptCounterTimeout) {
-                clearTimeout(this.resetAttemptCounterTimeout);
-                this.resetAttemptCounterTimeout = null;
-            }
-            this.attempt = 0;
-            this.lastTokenResponse = null;
-            console.log('CDNTokenManager: destroyed');
-        }
-        // -------------------------------------------------------------------------
-        // Static helpers
-        // -------------------------------------------------------------------------
-        static appendTokenParams(urlString, token, expires, tokenPath) {
-            const url = new URL(urlString);
-            if (token) {
-                url.searchParams.set('token', token);
-                if (expires !== null)
-                    url.searchParams.set('expires', String(expires));
-                if (tokenPath)
-                    url.searchParams.set('token_path', tokenPath);
-            }
-            return url.toString();
-        }
-        static appendAkamaiTokenParams(urlString, hdnea) {
-            const url = new URL(urlString);
-            url.searchParams.delete('hdnea');
-            url.searchParams.delete('hdntl');
-            url.searchParams.set('hdnea', hdnea);
-            return url.toString();
-        }
-        static appendDefaultTokenParams(urlString, tokenResponse) {
-            const url = new URL(urlString);
-            const params = tokenResponse.responseParameters;
-            if (params?.verify) {
-                url.searchParams.set('verify', params.verify);
-            }
-            if (params?.expires !== null && params?.expires !== undefined) {
-                url.searchParams.set('expires', String(params.expires));
-            }
-            return url.toString();
-        }
-    }
-
-    /**
-     * DrmConfigurator - Builds HLS DRM configuration objects.
-     *
-     * Isolates DRM complexity from engine initialization code.
-     * Ported from component/engines/hls.js init method (lines ~237-268).
-     *
-     * The licenseXhrSetup hook:
-     *   1. Calls tokenManager.extraParamsCallback() for auth token (if configured)
-     *   2. Sets Authorization: Bearer <accessToken> on the XHR request
-     *   3. Appends drm_custom_data from tokenManager.lastTokenResponse.extras to URL
-     *
-     * CRITICAL (from MEMORY.md): The licenseXhrSetup hook captures tokenManager
-     * via closure reference. The tokenManager is NEVER stored in PlayerState.
-     * DrmConfigurator holds a direct class-property reference.
-     */
-    class DrmConfigurator {
-        constructor(tokenManager) {
-            this.tokenManager = tokenManager;
-        }
-        /**
-         * Build the DRM-related fields for the HLS.js constructor config.
-         *
-         * Returns an empty object when emeEnabled is not set (no DRM).
-         * Returns emeEnabled, drmSystems, and licenseXhrSetup when DRM is configured.
-         */
-        buildHlsConfig(engineSettings) {
-            if (!engineSettings.emeEnabled) {
-                return {};
-            }
-            const tokenManager = this.tokenManager;
-            return {
-                emeEnabled: engineSettings.emeEnabled,
-                ...(engineSettings.drmSystems !== undefined && { drmSystems: engineSettings.drmSystems }),
-                licenseXhrSetup: async (xhr, url) => {
-                    // Step 1: Inject Authorization header from extraParamsCallback (if available)
-                    if (tokenManager?.extraParamsCallback) {
-                        const extraParams = await tokenManager.extraParamsCallback().catch((error) => {
-                            console.error('DrmConfigurator: extraParamsCallback error:', error);
-                            return null;
-                        });
-                        if (extraParams?.accessToken) {
-                            xhr.setRequestHeader('Authorization', `Bearer ${extraParams.accessToken}`);
-                        }
-                    }
-                    // Step 2: Append drm_custom_data from lastTokenResponse.extras to URL
-                    const customData = tokenManager?.lastTokenResponse?.extras?.drm_custom_data;
-                    if (customData) {
-                        const urlObject = new URL(url);
-                        urlObject.searchParams.delete('customdata'); // remove existing customdata if any
-                        urlObject.searchParams.append('customdata', customData);
-                        xhr.open('POST', urlObject.toString(), true);
-                    }
-                    else {
-                        xhr.open('POST', url, true);
-                    }
-                }
-            };
-        }
-    }
-
-    /**
-     * HLS retry handler.
-     *
-     * Registers an hlsError listener on the hls.js driver and attempts
-     * automatic recovery:
-     * - Fatal mediaError: calls recoverMediaError() after 1s
-     * - Fatal other error: calls startLoad() after 1s
-     * - Non-fatal error: re-checks after 3s; if currentTime has not advanced
-     *   (and Chromecast is not casting), applies the same recovery
-     */
-    function handleHlsRetry(driver, engine) {
-        driver.on('hlsError', (event, data) => {
-            console.warn(`HLS Retry: Error occured; ${data.fatal ? 'fatal, trying to fix now' : 'non fatal, monitor it'}.`, event, data);
-            if (data.fatal) {
-                setTimeout(() => {
-                    if (data.type === 'mediaError')
-                        driver.recoverMediaError();
-                    else
-                        driver.startLoad();
-                }, 1000);
-            }
-            else {
-                const errorTime = driver.media?.currentTime;
-                setTimeout(() => {
-                    if (errorTime === driver.media?.currentTime && !engine?.chromecast_casting) {
-                        console.warn('HLS Retry: Looks like stream is stuck, trying to fix', event, data);
-                        if (data?.type === 'mediaError')
-                            driver?.recoverMediaError();
-                        else
-                            driver.startLoad();
-                    }
-                    else
-                        console.info('HLS Retry: Stream is playing so this is fine', event, data);
-                }, 3000);
-            }
-        });
-    }
-
-    /**
-     * Workaround for hls.js bug: audio-stream-controller deadlocks when
-     * the audio playlist has more #EXT-X-DISCONTINUITY tags than video.
-     * Two symptoms:
-     * 1. WAITING_TRACK deadlock: onAudioTrackLoaded bails when
-     *    audio endCC > video endCC, caching data forever.
-     * 2. WAITING_INIT_PTS loop: audio fragments have CC values that
-     *    the video never produces initPTS for (e.g., audio CC=4,
-     *    video only has CC up to 2).
-     * Fix: remap audio fragment CC values and endCC to the video's
-     * CC range so both checks pass. The actual time alignment uses
-     * PDT (EXT-X-PROGRAM-DATE-TIME) as fallback.
-     * See https://github.com/video-dev/hls.js/issues/1484
-     *
-     * IMPORTANT: Must be called BEFORE driver.attachMedia() / driver.loadSource()
-     * (Pitfall 4: trigger is set up during construction, so patching after
-     * media attach may miss early events).
-     */
-    function applyDiscontinuityWorkaround(driver, hlsEvents) {
-        const origTrigger = driver.trigger;
-        driver.trigger = function (event, eventObject) {
-            if (event === hlsEvents.AUDIO_TRACK_LOADED) {
-                const eventData = eventObject;
-                if (eventData?.details) {
-                    const levelIdx = this.currentLevel >= 0 ? this.currentLevel : 0;
-                    const mainDetails = this.levels?.[levelIdx]?.details;
-                    if (mainDetails && eventData.details.endCC > mainDetails.endCC) {
-                        const mainEndCC = mainDetails.endCC;
-                        const frags = eventData.details.fragments;
-                        if (frags) {
-                            for (let index = 0; index < frags.length; index++) {
-                                if (frags[index].cc > mainEndCC) {
-                                    frags[index].cc = mainEndCC;
-                                }
-                            }
-                        }
-                        if (eventData.details.fragmentHint?.cc !== undefined && eventData.details.fragmentHint.cc > mainEndCC) {
-                            eventData.details.fragmentHint.cc = mainEndCC;
-                        }
-                        eventData.details.endCC = mainEndCC;
-                    }
-                }
-            }
-            return origTrigger.call(this, event, eventObject);
-        };
-    }
-
-    /**
-     * HlsEngine — HLS playback engine.
-     *
-     * Ported from component/engines/hls.js
-     *
-     * Extends BaseEngine to bridge hls.js driver events to PlayerState.
-     * Uses CDN loader, CDNTokenManager, DrmConfigurator, StallWatchdog,
-     * retry handler, and discontinuity workaround.
-     *
-     * CRITICAL: driver instance is a private class field — NEVER stored in PlayerState.
-     * CRITICAL: Call applyDiscontinuityWorkaround BEFORE driver.attachMedia/loadSource (Pitfall 4).
-     * CRITICAL: Never call driver.startLoad() from video 'play' event handler (Pitfall 3).
-     */
-    // ---------------------------------------------------------------------------
-    // HlsEngine
-    // ---------------------------------------------------------------------------
-    class HlsEngine extends BaseEngine {
-        constructor() {
-            super(...arguments);
-            // Private — NEVER in PlayerState (Pitfall 2)
-            this.driver = null;
-            this.tokenManager = null;
-            // Holds state reference for named driver event handlers
-            this.eventState = null;
-        }
-        // -------------------------------------------------------------------------
-        // BaseEngine hooks
-        // -------------------------------------------------------------------------
-        async onAttach() {
-            if (!this.state)
-                return;
-            // Pitfall 1: set loading state first, before any async work
-            this.state.playbackState = 'loading';
-            try {
-                await this.init();
-            }
-            catch (error) {
-                console.error('HlsEngine: init failed', error);
-                if (this.state) {
-                    this.state.error = error instanceof Error ? error.message : String(error);
-                }
-            }
-        }
-        onDetach() {
-            this.stopWatchdog();
-            if (this.driver !== null) {
-                try {
-                    this.driver.detachMedia();
-                    this.driver.destroy();
-                }
-                catch (error) {
-                    console.error('HlsEngine: error during driver teardown', error);
-                }
-                this.driver = null;
-            }
-            this.tokenManager = null;
-            this.eventState = null;
-        }
-        recoverFromStall(attempt) {
-            if (!this.driver)
-                return;
-            if (attempt === 1) {
-                console.warn('HlsEngine stall recovery: recoverMediaError');
-                this.driver.recoverMediaError();
-            }
-            else {
-                console.warn('HlsEngine stall recovery: startLoad');
-                this.driver.startLoad(this.video?.currentTime ?? -1);
-            }
-        }
-        // -------------------------------------------------------------------------
-        // Initialisation
-        // -------------------------------------------------------------------------
-        async init() {
-            const { config, video, state, signal } = this;
-            if (!config || !video || !state || !signal)
-                return;
-            const hlsjsUrl = config.hlsjs;
-            if (!hlsjsUrl) {
-                throw new Error('HlsEngine: config.hlsjs URL is required');
-            }
-            // Create token manager if a token URL is configured
-            if (config.token) {
-                this.tokenManager = new CDNTokenManager({
-                    token: config.token,
-                    tokenType: config.tokenType,
-                    srcInTokenRequest: config.srcInTokenRequest,
-                    extraParamsCallback: config.extraParamsCallback,
-                    onCDNTokenError: config.engineSettings.onCDNTokenError
-                });
-                // Fetch initial token
-                if (config.src) {
-                    await this.tokenManager.fetchToken({ src: config.src });
-                }
-            }
-            console.info('HlsEngine: loading hls.js from', hlsjsUrl);
-            const Hls = await loadScript(hlsjsUrl, 'Hls');
-            // Build DRM config
-            const drmConfigurator = new DrmConfigurator(this.tokenManager);
-            const drmConfig = drmConfigurator.buildHlsConfig(config.engineSettings);
-            // Capture tokenManager for closure use in pLoader (Pitfall 6)
-            const tokenManager = this.tokenManager;
-            // Build pLoader class for token-injected manifest requests
-            // pLoader captures tokenManager via closure to avoid `this` binding issues
-            class PLoader extends Hls.DefaultConfig.loader {
-                constructor(loaderConfig) {
-                    super(loaderConfig);
-                    const originalLoad = this.load.bind(this);
-                    this.load = async function (context, loadConfig, callbacks) {
-                        if (!context.url || !tokenManager) {
-                            originalLoad(context, loadConfig, callbacks);
-                            return;
-                        }
-                        // Only handle .m3u8 manifest URLs
-                        const parsedUrl = new URL(context.url);
-                        const lastSegment = parsedUrl.pathname.split('/').pop();
-                        if (!lastSegment.endsWith('.m3u8')) {
-                            originalLoad(context, loadConfig, callbacks);
-                            return;
-                        }
-                        // Refresh token params if expired
-                        context.url = await tokenManager.updateUrlWithTokenParams({ url: context.url });
-                        originalLoad(context, loadConfig, callbacks);
-                    };
-                }
-            }
-            // Build driver config
-            const engineSettings = config.engineSettings;
-            const driverConfig = {
-                autoStartLoad: !config.startAt,
-                enableWorker: true,
-                backBufferLength: 30,
-                ...engineSettings,
-                ...drmConfig,
-                startPosition: config.startAt,
-                pLoader: PLoader
-            };
-            // Inject custom ABR controller unless disabled
-            if (!config.disableCustomAbr) {
-                try {
-                    const { createHlsAbrController } = await Promise.resolve().then(function () { return hls; });
-                    driverConfig.abrController = createHlsAbrController(Hls);
-                }
-                catch (abrError) {
-                    console.warn('HlsEngine: failed to load custom ABR controller, using default', abrError);
-                }
-            }
-            // Create the driver (NEVER stored in state)
-            const driver = new Hls(driverConfig);
-            this.driver = driver;
-            // Pitfall 4: apply discontinuity workaround BEFORE attachMedia/loadSource
-            applyDiscontinuityWorkaround(driver, Hls.Events);
-            // Wire retry handler
-            if (config.retry) {
-                handleHlsRetry(driver);
-            }
-            // Bind native video element events to state
-            this.bindVideoEvents(video, state, signal);
-            // Attach media and load source
-            driver.attachMedia(video);
-            // Build source URL with token params if applicable
-            let src = config.src ?? '';
-            if (this.tokenManager && src) {
-                src = await this.tokenManager.updateUrlWithTokenParams({ url: src });
-            }
-            driver.loadSource(src);
-            // Register driver event handlers
-            this.registerDriverEvents(Hls, state);
-            // Start stall watchdog
-            this.startWatchdog();
-        }
-        // -------------------------------------------------------------------------
-        // Driver event mapping
-        // -------------------------------------------------------------------------
-        registerDriverEvents(Hls, state) {
-            const driver = this.driver;
-            if (!driver)
-                return;
-            this.eventState = state;
-            const { Events } = Hls;
-            driver.on(Events.MANIFEST_LOADED, this._onManifestLoaded.bind(this));
-            driver.on(Events.LEVEL_LOADED, this._onLevelLoaded.bind(this));
-            driver.on(Events.LEVEL_SWITCHED, this._onLevelSwitched.bind(this));
-            driver.on(Events.AUDIO_TRACKS_UPDATED, this._onAudioTracksUpdated.bind(this));
-            driver.on(Events.AUDIO_TRACK_SWITCHED, this._onAudioTrackSwitched.bind(this));
-            driver.on(Events.SUBTITLE_TRACKS_UPDATED, this._onSubtitleTracksUpdated.bind(this));
-            driver.on(Events.SUBTITLE_TRACK_SWITCH, this._onSubtitleTrackSwitch.bind(this));
-        }
-        _onManifestLoaded(_event, data) {
-            const state = this.eventState;
-            const driver = this.driver;
-            if (!state)
-                return;
-            const manifestData = data;
-            const levels = manifestData.levels ?? driver?.levels ?? [];
-            state.qualityLevels = levels.map((level, index) => ({
-                name: level.name ?? `${level.height}p`,
-                id: index,
-                bitrate: level.bitrate,
-                height: level.height,
-                width: level.width
-            }));
-        }
-        _onLevelLoaded(_event, data) {
-            const state = this.eventState;
-            if (!state)
-                return;
-            const levelData = data;
-            if (levelData?.details?.live !== undefined) {
-                state.isLive = levelData.details.live;
-            }
-        }
-        _onLevelSwitched(_event, data) {
-            const state = this.eventState;
-            if (!state)
-                return;
-            const switchedData = data;
-            state.currentQuality = switchedData.level;
-        }
-        _onAudioTracksUpdated(_event, data) {
-            const state = this.eventState;
-            const driver = this.driver;
-            if (!state)
-                return;
-            const audioData = data;
-            const tracks = audioData.audioTracks ?? driver?.audioTracks ?? [];
-            state.audioTracks = tracks.map((track) => ({
-                id: track.id,
-                name: track.name,
-                lang: track.lang
-            }));
-        }
-        _onAudioTrackSwitched(_event, data) {
-            const state = this.eventState;
-            if (!state)
-                return;
-            const switchData = data;
-            state.currentAudioTrack = switchData.id;
-        }
-        _onSubtitleTracksUpdated(_event, data) {
-            const state = this.eventState;
-            const driver = this.driver;
-            if (!state)
-                return;
-            const subtitleData = data;
-            const tracks = subtitleData.subtitleTracks ?? driver?.subtitleTracks ?? [];
-            state.subtitleTracks = tracks.map((track) => ({
-                id: track.id,
-                name: track.name,
-                lang: track.lang
-            }));
-        }
-        _onSubtitleTrackSwitch(_event, data) {
-            const state = this.eventState;
-            if (!state)
-                return;
-            const switchData = data;
-            state.currentSubtitleTrack = switchData.id;
-        }
-    }
-
-    /**
-     * DASH retry settings.
-     *
-     * Applies infinite retry configuration to the dash.js driver so that
-     * transient network failures (segment fetch, manifest re-fetch, etc.)
-     * never permanently stop playback.
-     */
-    function applyDashRetrySettings(driver) {
-        driver.updateSettings({
-            streaming: {
-                retryIntervals: {
-                    MPD: 1000,
-                    XLinkExpansion: 1000,
-                    InitializationSegment: 1000,
-                    IndexSegment: 1000,
-                    MediaSegment: 1000,
-                    BitstreamSwitchingSegment: 1000,
-                    other: 1000,
-                    lowLatencyReductionFactor: 1
-                }
-            }
-        });
-        driver.updateSettings({
-            streaming: {
-                retryAttempts: {
-                    MPD: Infinity,
-                    XLinkExpansion: Infinity,
-                    InitializationSegment: Infinity,
-                    IndexSegment: Infinity,
-                    MediaSegment: Infinity,
-                    BitstreamSwitchingSegment: Infinity,
-                    other: Infinity,
-                    lowLatencyMultiplyFactor: 1
-                }
-            }
-        });
-    }
-
-    /**
-     * DASH Custom ABR Rule
-     *
-     * Ported from component/engines/abr/dash.js
-     *
-     * Implements a buffer-and-throughput aware adaptive bitrate rule for dash.js.
-     * Applied via driver.addABRCustomRule('qualitySwitchRules', 'CustomAbrRule', factory).
-     */
-    const MAX_BUFFER_LENGTH = 15;
-    const PAST_BUFFER_FACTOR = 3;
-    // ---------------------------------------------------------------------------
-    // Internal helpers
-    // ---------------------------------------------------------------------------
-    const getAvgBandwidth = (requests, totalTime) => {
-        const [{ type, _tfinish, trequest, tresponse, trace }] = requests[0];
-        return type !== 'MediaSegment' && _tfinish && trequest && tresponse && trace && trace.length
-            ? trace.reduce((accumulator, traceEntry) => accumulator + traceEntry.b[0], 0) * 8 / totalTime
-            : 0;
-    };
-    const findNextBestLevel = (standardDeviation, rulesContext, avgBitrate, dashMetrics, downloadTime, count) => {
-        if (count <= 0)
-            return undefined;
-        const [{ bandwidth: currentBitrate }, { bandwidth: nextBitrate }] = rulesContext.getMediaInfo().bitrateList;
-        if ((count > 2) && (avgBitrate * 0.8 >= currentBitrate) && (avgBitrate <= nextBitrate)) {
-            return (standardDeviation < 8) ? count : count - 1;
-        }
-        if (count === 1) {
-            return (dashMetrics.getCurrentBufferLevel('video', true) > downloadTime * 1.5 && standardDeviation < 8)
-                ? count
-                : count - 1;
-        }
-        return undefined;
-    };
-    // ---------------------------------------------------------------------------
-    // createDashAbrRule
-    // ---------------------------------------------------------------------------
-    function createDashAbrRule(dashjs) {
-        const SwitchRequest = dashjs.FactoryMaker.getClassFactoryByName('SwitchRequest');
-        const StreamController = dashjs.FactoryMaker.getSingletonFactoryByName('StreamController');
-        const DashMetrics = dashjs.FactoryMaker.getSingletonFactoryByName('DashMetrics');
-        const addBufferValues = new Set();
-        let lastLoadedFragLevel = 0;
-        let lastBufferValue = 15;
-        let minBufferValue = 15;
-        const setBufferLength = (value) => {
-            /* istanbul ignore next */
-            if (value === undefined)
-                return;
-            if (lastBufferValue < value) {
-                addBufferValues.add(minBufferValue);
-                lastBufferValue = value;
-                minBufferValue = value;
-            }
-            if (value < minBufferValue) {
-                minBufferValue = value;
-                lastBufferValue = minBufferValue;
-            }
-        };
-        const getBestLevel = ({ requests, count, rulesContext, currentValue, dashMetrics }) => {
-            /* istanbul ignore next */
-            if (!requests)
-                return [''];
-            let lastRequest = null;
-            for (let index = requests.length - 1; (index >= 0) && (lastRequest === null); index--) {
-                const [{ _tfinish, trequest, tresponse, trace }] = requests[index];
-                if (_tfinish && trequest && tresponse && trace && trace.length) {
-                    lastRequest = requests[index];
-                }
-            }
-            if (lastRequest === null)
-                return ['No valid request made for this stream yet, bailing'];
-            const totalTime = (lastRequest[0]._tfinish.getTime() - lastRequest[0].trequest.getTime()) / 1000;
-            const downloadTime = (lastRequest[0]._tfinish.getTime() - lastRequest[0].tresponse.getTime()) / 1000;
-            if (lastRequest[0].type === 'InitializationSegment' || lastRequest[0].type === 'MediaSegment') {
-                if (totalTime <= 0) {
-                    return ['Last segment not downloaded, probable network problem: Switching to lowest quality', 0];
-                }
-                if (addBufferValues.size >= PAST_BUFFER_FACTOR) {
-                    const valuesArray = Array.from(addBufferValues);
-                    const avgBuffer = valuesArray.reduce((acc, val) => acc + val, 0) / addBufferValues.size;
-                    const avgBitrate = getAvgBandwidth(requests, totalTime);
-                    const sdBuffer = Math.sqrt(valuesArray.map((value) => (value - avgBuffer) ** 2).reduce((acc, val) => acc + val, 0) / addBufferValues.size);
-                    addBufferValues.clear();
-                    if (avgBuffer <= MAX_BUFFER_LENGTH * 0.1)
-                        return ['Avg. Buffer < 10% of max buffer, switching to lowest quality', 0];
-                    if (avgBuffer <= MAX_BUFFER_LENGTH * 0.3)
-                        return ['Maintaining the current Bitrate', currentValue];
-                    if ((avgBuffer <= MAX_BUFFER_LENGTH * 0.7) && (rulesContext.getMediaInfo().bitrateList[currentValue].bandwidth < avgBitrate)) {
-                        if ((lastLoadedFragLevel < count - 1) || (sdBuffer <= 8)) {
-                            return [
-                                'Switching to optimised quality level',
-                                !lastLoadedFragLevel
-                                    ? lastLoadedFragLevel + 1
-                                    : findNextBestLevel(sdBuffer, rulesContext, avgBitrate, dashMetrics, downloadTime, count)
-                            ];
-                        }
-                        return [
-                            'Switching to optimised quality level',
-                            findNextBestLevel(sdBuffer, rulesContext, avgBitrate, dashMetrics, downloadTime, count)
-                        ];
-                    }
-                    return [
-                        'Switching to optimised quality level',
-                        findNextBestLevel(sdBuffer, rulesContext, avgBitrate, dashMetrics, downloadTime, count)
-                    ];
-                }
-                return ['Maintaining the last loaded level'];
-            }
-            return ['Last Loaded segment was not a media segment of initialization segment'];
-        };
-        // The ABR rule factory function — assigned __dashjs_factory_name before passing to getClassFactory
-        const customAbr = function () {
-            const getMaxIndex = (rulesContext) => {
-                const switchRequest = SwitchRequest(this.context).create();
-                switchRequest.priority = SwitchRequest.PRIORITY.STRONG;
-                const mediaType = rulesContext.getMediaInfo().type;
-                const dashMetrics = DashMetrics(this.context).getInstance();
-                const streamController = StreamController(this.context).getInstance();
-                const abrController = rulesContext.getAbrController();
-                // Sample buffer level every second for adaptive decision
-                setInterval(() => {
-                    setBufferLength(dashMetrics.getCurrentBufferLevel('video', true));
-                }, 1000);
-                if (mediaType === 'video') {
-                    let level = 0;
-                    let reason;
-                    try {
-                        const [resultReason, resultLevel] = getBestLevel({
-                            requests: dashMetrics.getHttpRequests(mediaType),
-                            count: rulesContext.getMediaInfo().representationCount,
-                            currentValue: abrController.getQualityFor(mediaType, streamController.getActiveStreamInfo()),
-                            rulesContext,
-                            dashMetrics
-                        });
-                        reason = resultReason;
-                        level = resultLevel ?? lastLoadedFragLevel;
-                        lastLoadedFragLevel = level;
-                    }
-                    catch {
-                        addBufferValues.clear();
-                        return { quality: 0, reason: 'Error in ABR rule', priority: SwitchRequest.PRIORITY.STRONG };
-                    }
-                    switchRequest.quality = level;
-                    switchRequest.reason = reason;
-                    return switchRequest;
-                }
-                switchRequest.quality = 0;
-                switchRequest.reason = 'Audio Request';
-                return switchRequest;
-            };
-            return { getMaxIndex };
-        };
-        customAbr.__dashjs_factory_name = 'CustomAbrRule';
-        return dashjs.FactoryMaker.getClassFactory(customAbr);
-    }
-
-    /**
-     * DashEngine — DASH playback engine.
-     *
-     * Ported from component/engines/dash.js
-     *
-     * Extends BaseEngine to bridge dash.js MediaPlayer events to PlayerState.
-     * Uses CDN loader, CDNTokenManager, StallWatchdog, and DASH retry settings.
-     *
-     * CRITICAL: driver instance is a private class field — NEVER stored in PlayerState.
-     */
-    // ---------------------------------------------------------------------------
-    // DashEngine
-    // ---------------------------------------------------------------------------
-    class DashEngine extends BaseEngine {
-        constructor() {
-            super(...arguments);
-            // Private — NEVER in PlayerState
-            this.driver = null;
-            this.dvrErrorHandler = null;
-        }
-        // Set by the factory that wires up engine with config and bus before attach()
-        setConfig(config) {
-            this.config = config;
-        }
-        setBus(bus) {
-            this.bus = bus;
-        }
-        setVideo(video) {
-            this.video = video;
-        }
-        // -------------------------------------------------------------------------
-        // BaseEngine hooks
-        // -------------------------------------------------------------------------
-        async onAttach() {
-            if (!this.state)
-                return;
-            this.state.playbackState = 'loading';
-            try {
-                await this.init();
-            }
-            catch (error) {
-                console.error('DashEngine: init failed', error);
-                if (this.state) {
-                    this.state.error = error instanceof Error ? error.message : String(error);
-                }
-            }
-        }
-        onDetach() {
-            this.stopWatchdog();
-            if (this.driver !== null) {
-                try {
-                    this.driver.reset();
-                    this.driver.destroy();
-                }
-                catch (error) {
-                    console.error('DashEngine: error during driver teardown', error);
-                }
-                this.driver = null;
-            }
-            // DVR error handler cleanup — AbortSignal also handles it but be explicit
-            /* istanbul ignore next */
-            if (this.dvrErrorHandler !== null) {
-                window.removeEventListener('unhandledrejection', this.dvrErrorHandler);
-                this.dvrErrorHandler = null;
-            }
-        }
-        recoverFromStall(attempt) {
-            if (this.video === null)
-                return;
-            if (attempt === 1) {
-                console.warn('DashEngine stall recovery: seek nudge');
-                this.video.currentTime += 0.1;
-            }
-            else {
-                console.warn('DashEngine stall recovery: refreshManifest');
-                this.driver?.refreshManifest();
-            }
-        }
-        // -------------------------------------------------------------------------
-        // Initialisation
-        // -------------------------------------------------------------------------
-        async init() {
-            const { config, video, state, signal } = this;
-            if (!config || !video || !state || !signal)
-                return;
-            const dashjsUrl = config.dashjs;
-            if (!dashjsUrl) {
-                throw new Error('DashEngine: config.dashjs URL is required');
-            }
-            // Register DVR error suppression handler
-            // dash.js 4.7.4 throws unhandled rejections containing 'getCurrentDVRInfo'
-            this.dvrErrorHandler = (event) => {
-                const reason = event.reason;
-                if (reason?.message?.includes('getCurrentDVRInfo') ||
-                    String(event.reason).includes('getCurrentDVRInfo')) {
-                    event.preventDefault();
-                    console.warn('DashEngine: suppressed DVR unhandledrejection');
-                }
-            };
-            // Register with AbortSignal so it auto-removes when engine is detached
-            window.addEventListener('unhandledrejection', this.dvrErrorHandler, { signal });
-            console.info('DashEngine: loading dashjs from', dashjsUrl);
-            const dashjs = await loadScript(dashjsUrl, 'dashjs');
-            const player = dashjs.MediaPlayer().create();
-            if (!player) {
-                throw new Error('DashEngine: dash.js MediaPlayer could not be created');
-            }
-            this.driver = player;
-            player.initialize(video, config.src ?? '', config.autoplay ?? false);
-            // Apply retry settings if requested
-            if (config.retry) {
-                applyDashRetrySettings(player);
-            }
-            // Apply custom ABR rule unless disabled
-            if (!config.disableCustomAbr) {
-                const abrRule = createDashAbrRule(dashjs);
-                player.addABRCustomRule('qualitySwitchRules', 'CustomAbrRule', abrRule);
-            }
-            // Low-latency settings
-            if (config.lowLatency) {
-                player.updateSettings({
-                    streaming: {
-                        lowLatencyEnabled: true,
-                        liveDelay: 30,
-                        liveCatchUpPlaybackRate: 0.01
-                    }
-                });
-            }
-            // Wire driver events to PlayerState
-            this.registerDriverEvents(dashjs, state, player);
-            // Bind native video events
-            this.bindVideoEvents(video, state, signal);
-            // Start the stall watchdog
-            this.startWatchdog();
-            // Wait for stream to be initialised before marking ready
-            await new Promise((resolve) => {
-                const onInit = () => {
-                    player.off(dashjs.MediaPlayer.events['STREAM_INITIALIZED'], onInit);
-                    resolve();
-                };
-                player.on(dashjs.MediaPlayer.events['STREAM_INITIALIZED'], onInit);
-            });
-        }
-        // -------------------------------------------------------------------------
-        // Event mapping
-        // -------------------------------------------------------------------------
-        registerDriverEvents(dashjs, state, player) {
-            const events = dashjs.MediaPlayer.events;
-            // STREAM_INITIALIZED: populate quality levels, audio tracks, subtitle tracks, duration, isLive
-            player.on(events['STREAM_INITIALIZED'], () => {
-                const bitrateList = player.getBitrateInfoListFor('video');
-                state.qualityLevels = bitrateList.map((bitrateInfo, index) => ({
-                    name: `${bitrateInfo.height}p`,
-                    id: index,
-                    bitrate: bitrateInfo.bitrate
-                }));
-                const audioTracks = player.getTracksFor('audio');
-                state.audioTracks = audioTracks.map((track) => ({
-                    name: track.lang ?? '',
-                    id: track.id ?? track.index ?? 0
-                }));
-                const subtitleTracks = player.getTracksFor('fragmentedText');
-                state.subtitleTracks = subtitleTracks.map((track) => ({
-                    name: track.lang ?? '',
-                    id: track.id ?? track.index ?? 0
-                }));
-                const rawDuration = player.duration();
-                state.duration = Number.isFinite(rawDuration) ? Math.ceil(rawDuration) : 0;
-                // Determine live: if getCurrentLiveLatency() returns a valid number the stream is live
-                const liveLatency = player.getCurrentLiveLatency();
-                if (typeof this.config?.isLive === 'boolean') {
-                    state.isLive = this.config.isLive;
-                }
-                else {
-                    state.isLive = !Number.isNaN(liveLatency);
-                }
-                state.playbackState = 'playing';
-            });
-            // PLAYBACK_TIME_UPDATED: update currentTime
-            player.on(events['PLAYBACK_TIME_UPDATED'], () => {
-                state.currentTime = Math.round(player.time());
-            });
-            // QUALITY_CHANGE_REQUESTED: update currentQuality
-            player.on(events['QUALITY_CHANGE_REQUESTED'], () => {
-                state.currentQuality = player.getQualityFor('video');
-            });
-            // TRACK_CHANGE_RENDERED: update currentAudioTrack
-            player.on(events['TRACK_CHANGE_RENDERED'], () => {
-                state.currentAudioTrack = player.getQualityFor('audio');
-            });
-            // ERROR: log dash.js errors
-            player.on(events['ERROR'], (eventData) => {
-                const typedData = eventData;
-                console.warn('DashEngine error:', typedData?.error?.message ?? typedData?.error ?? typedData);
-            });
-        }
-    }
-
-    /**
-     * Poster HLS handler.
-     *
-     * Used to play a looping HLS stream as a video poster/background.
-     * The Hls constructor is passed at attach-time (not imported) because
-     * hls.js is loaded from CDN at runtime.
-     */
-    function createPosterHandler() {
-        let player = null;
-        return {
-            attach({ src, container, Hls }) {
-                console.log('Poster HLS: attach media', src, container);
-                player = new Hls();
-                player.loadSource(src);
-                player.attachMedia(container);
-            },
-            close() {
-                if (player) {
-                    try {
-                        player.detachMedia?.();
-                        player.destroy?.();
-                    }
-                    catch (error) {
-                        console.error('Poster HLS player close error:', error);
-                    }
-                    player = null;
-                }
-            },
-            play() {
-                player?.media?.play();
-            },
-            pause() {
-                player?.media?.pause();
-            }
-        };
-    }
-
-    /**
-     * iOS HLS handler.
-     *
-     * Used when Hls.isSupported() returns false (native HLS on iOS Safari).
-     * Native video elements may not report correct duration for live streams,
-     * so this handler parses the HLS manifest directly to sum EXTINF durations.
-     *
-     * Fetches the master manifest, extracts the first child manifest URL,
-     * then polls every 5 seconds to keep duration up-to-date.
-     */
-    function createIosHandler(src) {
-        const data = {};
-        let intervalId;
-        async function init() {
-            const masterResponse = await fetch(src);
-            const masterManifest = await masterResponse.text();
-            const childLine = masterManifest
-                .split('\n')
-                .find((line) => /^[^#]+\.m3u8/i.test(line));
-            if (!childLine)
-                return;
-            const { href: childAddress } = new URL(childLine, src);
-            async function pollDuration() {
-                const childResponse = await fetch(childAddress);
-                const childManifest = await childResponse.text();
-                data.duration = childManifest
-                    .split('\n')
-                    .filter((line) => line.indexOf('#EXTINF:') !== -1)
-                    .map((line) => Number(line.split(':')[1].replace(',', '')))
-                    .reduce((accumulated, duration) => accumulated + duration, 0);
-            }
-            intervalId = setInterval(() => {
-                pollDuration().catch((error) => {
-                    console.warn('iOS HLS: Failed to poll child manifest duration', error);
-                });
-            }, 5000);
-        }
-        init().catch((error) => {
-            console.warn('iOS HLS: Failed to initialize from master manifest', error);
-        });
-        return {
-            data,
-            destroy() {
-                if (intervalId !== undefined)
-                    clearInterval(intervalId);
-            }
-        };
-    }
-
-    /**
-     * Custom HLS ABR controller.
-     *
-     * Ported from component/engines/abr/hls.js (509 LOC).
-     *
-     * Creates a class that extends hls.js's built-in ABR controller and overrides
-     * nextAutoLevel with bandwidth-aware and buffer-level-based quality selection.
-     *
-     * Usage: pass the result as `abrController` in the Hls constructor config.
-     *
-     * Note: hls.js internals are accessed via type assertions because the library
-     * does not export its internal controller types (Open Question 3 in RESEARCH.md).
-     */
-    // ---------------------------------------------------------------------------
-    // Standard deviation helper
-    // ---------------------------------------------------------------------------
-    function standardDeviation(arr) {
-        const mean = arr.reduce((accumulator, value) => accumulator + value, 0) / arr.length;
-        const squaredDiffs = arr.map((value) => (value - mean) ** 2);
-        return Math.sqrt(squaredDiffs.reduce((accumulator, value) => accumulator + value, 0) / (arr.length - 1));
-    }
-    // ---------------------------------------------------------------------------
-    // Playlist level type constants (inlined to avoid hls.js internal import)
-    // ---------------------------------------------------------------------------
-    const PlaylistLevelType = {
-        MAIN: 'main'};
-    // ---------------------------------------------------------------------------
-    // Buffer helper (simplified version of hls.js's BufferHelper)
-    // ---------------------------------------------------------------------------
-    const BufferHelperImpl = {
-        bufferInfo(media, pos, maxHoleDuration) {
-            if (!media.buffered || media.buffered.length === 0) {
-                return { end: 0, start: 0, len: 0, nextStart: 0 };
-            }
-            for (let index = 0; index < media.buffered.length; index++) {
-                const start = media.buffered.start(index);
-                const end = media.buffered.end(index);
-                if (pos >= start - maxHoleDuration && pos <= end + maxHoleDuration) {
-                    return { end, start, len: end - pos, nextStart: 0 };
-                }
-            }
-            return { end: 0, start: 0, len: 0, nextStart: 0 };
-        }
-    };
-    // ---------------------------------------------------------------------------
-    // createHlsAbrController
-    // ---------------------------------------------------------------------------
-    /**
-     * Factory that creates a custom ABR controller class extending hls.js's built-in
-     * ABR controller. Takes the Hls constructor so it can access Events and DefaultConfig.
-     *
-     * The returned class can be passed as `abrController` in the Hls constructor config.
-     */
-    function createHlsAbrController(HlsConstructor) {
-        const BaseAbrController = HlsConstructor.DefaultConfig.abrController;
-        // If no base controller is available, return a no-op fallback
-        if (!BaseAbrController) {
-            return class FallbackAbrController {
-                constructor(_hlsInstance) { }
-                get nextAutoLevel() { return -1; }
-                set nextAutoLevel(_value) { }
-                destroy() { }
-            };
-        }
-        const { Events } = HlsConstructor;
-        class CustomAbrController extends BaseAbrController {
-            constructor(hlsInstance) {
-                super(hlsInstance, Events.FRAG_LOADING, Events.FRAG_LOADED, Events.FRAG_BUFFERED, Events.ERROR);
-                this.hls = hlsInstance;
-                this.lastLoadedLevel = 1;
-                this._nextAutoLevel = -1;
-                this.onCheck = this._abandonRulesCheck.bind(this);
-                this.onBufferCheckTick = this._onBufferCheckTick.bind(this);
-                this.bufferCheckLastPlayPos = 0;
-                this.bufferCheckCurrentPlayPos = 0;
-                this.bufferCheckBufferingDetected = false;
-                this.lastDuration = 6;
-                this.setBufferValues = new Set();
-                this.setBitrate = new Set();
-                this.loading = false;
-                this.playingTime = 0;
-                this.minBufferValue = 30;
-                this.maxBufferValue = 0;
-                this.lastBufferValue = 30;
-                this.maxBufferLength = 30;
-                this.rebuffering = 0;
-                this.rebufferingRatio = 0.15;
-                this.pastBufferFactor = 5;
-                this.bitrateTestDelay = 0;
-                this.timer = undefined;
-                this.bufferCheckTimer = undefined;
-                this.init = true;
-                this.fraglastBuffered = 0;
-                this.lastLoadedFragLevel = 1;
-                this.fragCurrent = null;
-                this.partCurrent = null;
-                this.bufferCheckVideo = null;
-                this.registerCustomListeners();
-            }
-            destroy() {
-                this.unregisterCustomListeners();
-                this.clearCustomTimer();
-                if (this.bufferCheckTimer !== undefined) {
-                    clearInterval(this.bufferCheckTimer);
-                    this.bufferCheckTimer = undefined;
-                }
-                if (typeof super.destroy === 'function') {
-                    super.destroy();
-                }
-            }
-            registerCustomListeners() {
-                this.hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
-                this.hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
-                this.hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
-                this.hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
-                this.hls.on(Events.ERROR, this.onError, this);
-            }
-            unregisterCustomListeners() {
-                this.hls.off(Events.FRAG_LOADING, this.onFragLoading, this);
-                this.hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
-                this.hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
-                this.hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
-                this.hls.off(Events.ERROR, this.onError, this);
-            }
-            clearCustomTimer() {
-                if (this.timer !== undefined) {
-                    clearInterval(this.timer);
-                    this.timer = undefined;
-                }
-            }
-            onFragLoading(_event, data) {
-                const fragData = data;
-                const { frag } = fragData;
-                this.loading = true;
-                if (frag.type === PlaylistLevelType.MAIN) {
-                    if (!this.timer) {
-                        this.fragCurrent = frag;
-                        this.partCurrent = fragData.part ?? null;
-                        this.timer = setInterval(this.onCheck, 100);
-                    }
-                }
-            }
-            getBuffer() {
-                if (!this.hls.media)
-                    return 0;
-                const playbackRate = this.hls.media.playbackRate || 1;
-                const pos = this.hls.media.currentTime;
-                const bufferInfo = BufferHelperImpl.bufferInfo(this.hls.media, pos, this.maxBufferLength);
-                return (bufferInfo.end - pos) / playbackRate;
-            }
-            _abandonRulesCheck() {
-                const { hls } = this;
-                const video = hls.media;
-                const frag = this.fragCurrent;
-                const part = this.partCurrent;
-                if (!frag || !video)
-                    return;
-                const stats = part ? part.stats : frag.stats;
-                if (stats.aborted) {
-                    this.clearCustomTimer();
-                    this._nextAutoLevel = -1;
-                    return;
-                }
-                if (!hls.autoLevelEnabled || video.paused || !video.playbackRate || !video.readyState)
-                    return;
-                if (frag.type !== PlaylistLevelType.MAIN || frag.sn === 'initSegment')
-                    return;
-                this.bufferCheckLastPlayPos = 0;
-                this.bufferCheckCurrentPlayPos = 0;
-                this.bufferCheckBufferingDetected = false;
-                this.bufferCheckVideo = video;
-                this.bufferCheckTimer = setInterval(this.onBufferCheckTick, 1000);
-            }
-            _onBufferCheckTick() {
-                if (!this.hls)
-                    return;
-                if (this.loading === false) {
-                    const bufferLength = this.getBuffer();
-                    this.getBufferMinMaxValue(bufferLength);
-                }
-                const video = this.bufferCheckVideo;
-                if (!video)
-                    return;
-                this.playingTime += 1;
-                this.bufferCheckCurrentPlayPos = video.currentTime;
-                if (this.bufferCheckLastPlayPos > 0 && video.paused && !this.bufferCheckBufferingDetected && this.bufferCheckCurrentPlayPos <= this.bufferCheckLastPlayPos) {
-                    this.rebuffering += 1;
-                    this.bufferCheckBufferingDetected = true;
-                    if (this.hls.currentLevel > 0) {
-                        this.reset();
-                        if (this.lastLoadedFragLevel !== 0) {
-                            this.clearCustomTimer();
-                        }
-                    }
-                }
-                if (this.bufferCheckLastPlayPos > 0 && this.bufferCheckBufferingDetected && !video.paused && this.bufferCheckCurrentPlayPos > this.bufferCheckLastPlayPos) {
-                    this.bufferCheckBufferingDetected = false;
-                }
-                this.bufferCheckLastPlayPos = this.bufferCheckCurrentPlayPos;
-            }
-            onFragLoaded(_event, data) {
-                const fragData = data;
-                const { frag, part } = fragData;
-                const stats = part ? part.stats : frag.stats;
-                const duration = part ? part.duration : frag.duration;
-                this.loading = false;
-                if (frag.type === PlaylistLevelType.MAIN && typeof frag.sn === 'number') {
-                    this.clearCustomTimer();
-                    this.lastLoadedFragLevel = frag.level;
-                    this._nextAutoLevel = -1;
-                    const level = this.hls.levels[frag.level];
-                    if (level) {
-                        const loadedBytes = (level.loaded ? level.loaded.bytes : 0) + stats.loaded;
-                        const loadedDuration = (level.loaded ? level.loaded.duration : 0) + duration;
-                        level.loaded = { bytes: loadedBytes, duration: loadedDuration };
-                        level.realBitrate = Math.round((8 * loadedBytes) / loadedDuration);
-                        this.setBitrate.add(level.realBitrate);
-                        this.lastDuration = duration;
-                        this.maxBufferLength = this.lastDuration * 10;
-                    }
-                    // Trigger onFragBuffered inline
-                    this.onFragBuffered(Events.FRAG_BUFFERED, { stats, frag, part, id: frag.type });
-                }
-            }
-            getBufferMinMaxValue(value) {
-                if (this.lastBufferValue < value) {
-                    this.setBufferValues.add(this.minBufferValue);
-                    this.maxBufferValue = value;
-                    this.lastBufferValue = value;
-                    this.minBufferValue = value;
-                }
-                if (value > this.maxBufferValue) {
-                    this.maxBufferValue = value;
-                }
-                if (value < this.minBufferValue) {
-                    this.minBufferValue = value;
-                    this.lastBufferValue = this.minBufferValue;
-                }
-            }
-            reset() {
-                this.setBufferValues.clear();
-                this.setBitrate.clear();
-            }
-            onError(_event, data) {
-                const errorData = data;
-                switch (errorData.details) {
-                    case 'fragLoadTimeOut':
-                        this.clearCustomTimer();
-                        break;
-                }
-            }
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            onLevelLoaded(_event, _data) {
-                // No-op: level details updated via getBuffer on demand
-            }
-            onFragBuffered(_event, data) {
-                const fragData = data;
-                const { frag, part } = fragData;
-                const stats = part ? part.stats : (fragData.stats ?? frag.stats);
-                if (stats.aborted)
-                    return;
-                if (frag.type !== PlaylistLevelType.MAIN || frag.sn === 'initSegment')
-                    return;
-                const loadingStart = stats.loading?.start ?? 0;
-                const parsingEnd = stats.parsing?.end ?? 0;
-                const fragLoadingProcessingMs = parsingEnd - loadingStart;
-                this.bitrateTestDelay = fragLoadingProcessingMs / 1000;
-                this.fraglastBuffered = Date.now();
-            }
-            findNextBestLevel(sd) {
-                const levels = this.hls.levels;
-                for (let index = 0; index < levels.length; index++) {
-                    if (index < levels.length - 2
-                        && (this.avgBitrate * 0.8) >= levels[index].bitrate
-                        && this.avgBitrate <= levels[index + 1].bitrate) {
-                        this.reset();
-                        this.lastLoadedFragLevel = (sd < 3) ? index : index - 1;
-                        return this.lastLoadedFragLevel;
-                    }
-                    if (index === levels.length - 1) {
-                        const buffer = this.getBuffer();
-                        if (buffer > this.lastDuration + (this.lastDuration / 2) && sd < 3) {
-                            this.lastLoadedFragLevel = index;
-                        }
-                        else {
-                            this.lastLoadedFragLevel = index - 1;
-                        }
-                        this.reset();
-                        return this.lastLoadedFragLevel;
-                    }
-                }
-                return this.lastLoadedFragLevel;
-            }
-            get avgBitrate() {
-                if (this.setBitrate.size === 0)
-                    return 0;
-                return Array.from(this.setBitrate).reduce((acc, val) => acc + val, 0) / this.setBitrate.size;
-            }
-            /* istanbul ignore next */
-            set avgBitrate(_value) {
-                // Computed from setBitrate; setter is a no-op; required by TypeScript accessor rules
-            }
-            findBestLevel() {
-                if (!this.hls)
-                    return 0;
-                const maxLevel = this.hls.levels.length - 1;
-                const minLevel = 0;
-                const bufferLength = this.getBuffer();
-                // Low buffer: drop quality
-                if (bufferLength < (this.hls.config.maxBufferLength * 0.10)) {
-                    this.reset();
-                    this.lastLoadedFragLevel = Math.max(this.lastLoadedFragLevel - 1, 0);
-                    this.lastLoadedFragLevel = Math.min(Math.max(this.lastLoadedFragLevel, minLevel), maxLevel);
-                    return this.lastLoadedFragLevel;
-                }
-                // Note: the fraglastBuffered stale-buffer check was removed here.
-                // The original code contained an inner buffer re-check that was structurally
-                // unreachable (duplicate check mirrors the outer low-buffer check at line 480).
-                // Init: start at highest quality
-                if (this.init === true) {
-                    this.init = false;
-                    this.lastLoadedFragLevel = maxLevel;
-                    return this.lastLoadedFragLevel;
-                }
-                // Good buffer: select quality based on bitrate (only called when setBitrate is non-empty)
-                if (bufferLength > this.hls.config.maxBufferLength * 0.30) {
-                    this.lastLoadedFragLevel = this.findNextBestLevel(5);
-                    this.lastLoadedFragLevel = Math.min(Math.max(this.lastLoadedFragLevel, minLevel), maxLevel);
-                    return this.lastLoadedFragLevel;
-                }
-                // Historical buffer stats available
-                if (this.setBufferValues.size >= this.pastBufferFactor) {
-                    try {
-                        const avgBuffer = Array.from(this.setBufferValues).reduce((acc, val) => acc + val, 0) / this.setBufferValues.size;
-                        const sdBuffer = standardDeviation(Array.from(this.setBufferValues));
-                        this.setBufferValues.clear();
-                        const currentBitrate = this.hls.levels[this.hls.currentLevel]?.bitrate ?? 0;
-                        if (avgBuffer <= this.hls.config.maxBufferLength * 0.1 && currentBitrate >= this.hls.levels[0].bitrate) {
-                            this.reset();
-                            this.lastLoadedFragLevel = Math.max(this.lastLoadedFragLevel - 1, 0);
-                            this.lastLoadedFragLevel = Math.min(Math.max(this.lastLoadedFragLevel, minLevel), maxLevel);
-                            return this.lastLoadedFragLevel;
-                        }
-                        if (avgBuffer <= this.hls.config.maxBufferLength * 0.3) {
-                            this.reset();
-                            return this.lastLoadedFragLevel;
-                        }
-                        if (avgBuffer <= this.hls.config.maxBufferLength * 0.7 && currentBitrate < this.avgBitrate) {
-                            this.reset();
-                            this.lastLoadedFragLevel = this.findNextBestLevel(sdBuffer);
-                            this.lastLoadedFragLevel = Math.min(Math.max(this.lastLoadedFragLevel, minLevel), maxLevel);
-                            return this.lastLoadedFragLevel;
-                        }
-                        if (avgBuffer > this.hls.config.maxBufferLength * 0.7 && currentBitrate < this.avgBitrate * 0.8) {
-                            this.lastLoadedFragLevel = this.findNextBestLevel(sdBuffer);
-                            this.lastLoadedFragLevel = Math.min(Math.max(this.lastLoadedFragLevel, minLevel), maxLevel);
-                            return this.lastLoadedFragLevel;
-                        }
-                        this.reset();
-                        this.lastLoadedFragLevel = Math.min(Math.max(this.lastLoadedFragLevel, minLevel), maxLevel);
-                        return this.lastLoadedFragLevel;
-                    }
-                    catch (error) {
-                        console.warn('HLS ABR: findBestLevel error', error);
-                        this.lastLoadedFragLevel = this.findNextBestLevel(3);
-                        this.lastLoadedFragLevel = Math.min(Math.max(this.lastLoadedFragLevel, minLevel), maxLevel);
-                        return this.lastLoadedFragLevel;
-                    }
-                }
-                this.lastLoadedFragLevel = Math.min(Math.max(this.lastLoadedFragLevel, minLevel), maxLevel);
-                return this.lastLoadedFragLevel;
-            }
-            get _nextABRAutoLevel() {
-                try {
-                    if (this.playingTime > 0 && (this.rebuffering / this.playingTime) > this.rebufferingRatio) {
-                        this.lastLoadedFragLevel = 0;
-                        return 0;
-                    }
-                    if (this.setBitrate.size > 0) {
-                        this.lastLoadedFragLevel = this.findBestLevel();
-                    }
-                    return this.lastLoadedFragLevel;
-                }
-                catch (error) {
-                    console.warn('HLS ABR: Could not define level, using last loaded level', error);
-                    return this.lastLoadedFragLevel;
-                }
-            }
-            get nextAutoLevel() {
-                return this._nextABRAutoLevel;
-            }
-            set nextAutoLevel(nextLevel) {
-                this._nextAutoLevel = nextLevel;
-            }
-        }
-        return CustomAbrController;
-    }
-
-    var hls = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        createHlsAbrController: createHlsAbrController
-    });
-
-    /**
-     * HLS Snapshot Handler.
-     *
-     * Ported from component/engines/snapshot/hls.js (102 LOC).
-     *
-     * Creates a separate Hls instance for seekbar thumbnail preview rendering.
-     * The snapshot instance runs independently from the main playback engine with
-     * its own off-screen video element and low-buffer settings.
-     *
-     * Token injection (Pitfall 6): tokenManager is captured via closure,
-     * not stored on `this`, to avoid binding issues inside pLoader.
-     */
-    // ---------------------------------------------------------------------------
-    // HlsSnapshotHandler
-    // ---------------------------------------------------------------------------
-    class HlsSnapshotHandler {
-        constructor(config, tokenManager) {
-            this.driver = null;
-            this.offscreenVideo = null;
-            this.throttleTimeout = null;
-            this.pendingSeekTime = 0;
-            this.config = config;
-            this.tokenManager = tokenManager;
-        }
-        /**
-         * Initialize the snapshot Hls instance using the CDN-loaded Hls constructor.
-         * Creates a separate Hls instance with minimal buffering for thumbnail generation.
-         */
-        init(HlsConstructor) {
-            // Create an off-screen video element for the snapshot player
-            const offscreenVideo = document.createElement('video');
-            offscreenVideo.preload = 'none';
-            this.offscreenVideo = offscreenVideo;
-            // Capture tokenManager via closure (Pitfall 6)
-            const tokenManager = this.tokenManager;
-            // Build pLoader class with token injection for manifest requests
-            let PLoader;
-            if (tokenManager) {
-                class SnapshotPLoader extends HlsConstructor.DefaultConfig.loader {
-                    constructor(loaderConfig) {
-                        super(loaderConfig);
-                        const originalLoad = this.load.bind(this);
-                        this.load = async function (context, loadConfig, callbacks) {
-                            if (!context.url) {
-                                originalLoad(context, loadConfig, callbacks);
-                                return;
-                            }
-                            // Only handle .m3u8 manifest URLs
-                            const parsedUrl = new URL(context.url);
-                            const lastSegment = parsedUrl.pathname.split('/').pop();
-                            if (!lastSegment.endsWith('.m3u8')) {
-                                originalLoad(context, loadConfig, callbacks);
-                                return;
-                            }
-                            // Refresh token if expired (tokenManager is non-null within this if block)
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            context.url = await tokenManager.updateUrlWithTokenParams({ url: context.url });
-                            originalLoad(context, loadConfig, callbacks);
-                        };
-                    }
-                }
-                PLoader = SnapshotPLoader;
-            }
-            const driverConfig = {
-                startLevel: 0,
-                enableWebVTT: false,
-                maxBufferLength: 1,
-                ...(this.config.engineSettings ?? {}),
-                ...(PLoader ? { pLoader: PLoader } : {})
-            };
-            const driver = new HlsConstructor(driverConfig);
-            this.driver = driver;
-            // Apply discontinuity workaround before attaching
-            applyDiscontinuityWorkaround(driver, HlsConstructor.Events);
-            driver.attachMedia(offscreenVideo);
-            if (this.config.src) {
-                driver.loadSource(this.config.src);
-            }
-        }
-        /**
-         * Seek the snapshot player to the specified time.
-         * Throttled to avoid excessive seeks (250ms minimum interval).
-         */
-        take(time) {
-            if (!this.offscreenVideo)
-                return;
-            if (this.throttleTimeout !== null) {
-                clearTimeout(this.throttleTimeout);
-            }
-            this.pendingSeekTime = time;
-            this.throttleTimeout = setTimeout(this.applyPendingSeek.bind(this), 250);
-        }
-        applyPendingSeek() {
-            if (this.offscreenVideo) {
-                this.offscreenVideo.currentTime = this.pendingSeekTime;
-            }
-            this.throttleTimeout = null;
-        }
-        /**
-         * Destroy the snapshot Hls instance and clean up resources.
-         */
-        destroy() {
-            if (this.throttleTimeout !== null) {
-                clearTimeout(this.throttleTimeout);
-                this.throttleTimeout = null;
-            }
-            if (this.driver !== null) {
-                try {
-                    this.driver.detachMedia();
-                    this.driver.destroy();
-                }
-                catch (error) {
-                    console.warn('HlsSnapshotHandler: error during destroy', error);
-                }
-                this.driver = null;
-            }
-            this.offscreenVideo = null;
-        }
-    }
-
-    /**
-     * DASH Snapshot Handler
-     *
-     * Ported from component/engines/snapshot/dash.js
-     *
-     * Creates a separate dash.js MediaPlayer instance for seekbar preview thumbnails.
-     * The snapshot player runs in an off-screen video element and is independent
-     * from the main playback player.
-     */
-    // ---------------------------------------------------------------------------
-    // DashSnapshotHandler
-    // ---------------------------------------------------------------------------
-    class DashSnapshotHandler {
-        constructor(src) {
-            this.player = null;
-            this.offscreenVideo = null;
-            this.ready = false;
-            this.src = src;
-        }
-        /**
-         * Initialise the snapshot player using the provided dashjs constructor.
-         * Resolves with a SnapshotHandle once STREAM_INITIALIZED fires.
-         * If initialisation fails, resolves with a no-op handle.
-         */
-        init(dashjs) {
-            const noopHandle = { take: () => undefined, destroy: () => undefined };
-            return new Promise((resolve) => {
-                const video = document.createElement('video');
-                video.style.display = 'none';
-                document.body.appendChild(video);
-                this.offscreenVideo = video;
-                let player;
-                try {
-                    player = dashjs.MediaPlayer().create();
-                    this.player = player;
-                    player.initialize(video, this.src, false);
-                    player.updateSettings({
-                        streaming: {
-                            text: { defaultEnabled: false },
-                            buffer: { fastSwitchEnabled: false },
-                            abr: {
-                                autoSwitchBitrate: { video: false, audio: false },
-                                initialBitrate: { video: 0, audio: 0 }
-                            }
-                        }
-                    });
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    console.warn('Snapshot handler initialization failed:', message);
-                    this.cleanup();
-                    resolve(noopHandle);
-                    return;
-                }
-                // Handle errors gracefully
-                player.on(dashjs.MediaPlayer.events['ERROR'], (eventData) => {
-                    const typedData = eventData;
-                    console.warn('Snapshot dash.js error:', typedData?.error?.message ?? typedData?.error ?? typedData);
-                });
-                const onStreamInitialized = () => {
-                    player.setMute(true);
-                    player.off(dashjs.MediaPlayer.events['STREAM_INITIALIZED'], onStreamInitialized);
-                    this.ready = true;
-                    let throttleTimer = null;
-                    const handle = {
-                        take: (time) => {
-                            if (!this.ready)
-                                return;
-                            if (throttleTimer !== null)
-                                return;
-                            throttleTimer = setTimeout(() => {
-                                throttleTimer = null;
-                            }, 250);
-                            try {
-                                player.seek(time);
-                                if (player.isPaused())
-                                    player.play();
-                            }
-                            catch (error) {
-                                const message = error instanceof Error ? error.message : String(error);
-                                console.warn('Snapshot seek error:', message);
-                            }
-                        },
-                        destroy: () => {
-                            this.ready = false;
-                            this.destroy();
-                        }
-                    };
-                    resolve(handle);
-                };
-                player.on(dashjs.MediaPlayer.events['STREAM_INITIALIZED'], onStreamInitialized);
-                // Pause immediately when playback starts — we only seek, never play
-                player.on(dashjs.MediaPlayer.events['PLAYBACK_PLAYING'], () => {
-                    if (!player.isPaused())
-                        player.pause();
-                });
-            });
-        }
-        /**
-         * Reset and destroy the snapshot player and remove the off-screen video element.
-         */
-        destroy() {
-            this.ready = false;
-            if (this.player !== null) {
-                try {
-                    this.player.reset();
-                }
-                catch {
-                    // Ignore reset errors
-                }
-                this.player = null;
-            }
-            this.cleanup();
-        }
-        cleanup() {
-            if (this.offscreenVideo !== null) {
-                this.offscreenVideo.remove();
-                this.offscreenVideo = null;
-            }
-        }
-    }
-
-    exports.BaseEngine = BaseEngine;
-    exports.CDNTokenManager = CDNTokenManager;
-    exports.DashEngine = DashEngine;
-    exports.DashSnapshotHandler = DashSnapshotHandler;
-    exports.DrmConfigurator = DrmConfigurator;
-    exports.HlsEngine = HlsEngine;
-    exports.HlsSnapshotHandler = HlsSnapshotHandler;
-    exports.StallWatchdog = StallWatchdog;
-    exports.applyDashRetrySettings = applyDashRetrySettings;
-    exports.applyDiscontinuityWorkaround = applyDiscontinuityWorkaround;
-    exports.createDashAbrRule = createDashAbrRule;
-    exports.createHlsAbrController = createHlsAbrController;
-    exports.createIosHandler = createIosHandler;
-    exports.createPosterHandler = createPosterHandler;
-    exports.handleHlsRetry = handleHlsRetry;
-    exports.loadScript = loadScript;
-
-}));
-//# sourceMappingURL=ebplayer-engines.bundle.js.map