eb-player 2.0.20 → 2.1.0

package/dist/build/types/src/engines/dash.d.ts

@@ -0,0 +1,100 @@
+/**
+ * DashEngine — DASH playback engine.
+ *
+ * Ported from component/engines/dash.js
+ *
+ * Extends BaseEngine to bridge dash.js MediaPlayer events to PlayerState.
+ * Uses the CDN loader and StallWatchdog, plus DASH retry settings and ABR rules.
+ *
+ * CDN token signing (manifests and segments alike) is HLS-only by design —
+ * this engine has no `CDNTokenManager` integration at all (Phase 08.1 / D-05).
+ * DASH segments are `.m4s`, so nothing written for HLS's fragment-loader
+ * token signing should be assumed to generalise here.
+ *
+ * CRITICAL: driver instance is a private class field — NEVER stored in PlayerState.
+ */
+import { BaseEngine } from './base-engine';
+import type { PlayerConfig } from '../core/config';
+import type { TypedEventBus } from '../core/event-bus';
+interface BitrateInfo {
+    height: number;
+    width: number;
+    bitrate: number;
+    qualityIndex: number;
+}
+interface MediaTrack {
+    id?: string | number;
+    index?: number;
+    lang?: string;
+    [key: string]: unknown;
+}
+interface DashPlayerInstance {
+    initialize: (element: HTMLVideoElement, src: string, autoplay?: boolean) => void;
+    on: (event: string, handler: (data?: unknown) => void) => void;
+    off: (event: string, handler: (data?: unknown) => void) => void;
+    getTracksFor: (type: string) => MediaTrack[];
+    getBitrateInfoListFor: (type: string) => BitrateInfo[];
+    getQualityFor: (type: string) => number;
+    setQualityFor: (type: string, index: number) => void;
+    setCurrentTrack: (track: MediaTrack) => void;
+    getCurrentLiveLatency: () => number;
+    time: () => number;
+    duration: () => number;
+    updateSettings: (settings: Record<string, unknown>) => void;
+    addABRCustomRule: (ruleType: string, ruleName: string, rule: unknown) => void;
+    refreshManifest: () => void;
+    reset: () => void;
+    destroy: () => void;
+    seek: (time: number) => void;
+    [key: string]: unknown;
+}
+interface DashPlayerConstructor {
+    (): {
+        create: () => DashPlayerInstance;
+    };
+    events: Record<string, string>;
+}
+export interface DashjsType {
+    MediaPlayer: DashPlayerConstructor;
+    FactoryMaker: {
+        getClassFactoryByName: (name: string) => unknown;
+        getSingletonFactoryByName: (name: string) => unknown;
+        getClassFactory: (fn: unknown) => unknown;
+    };
+}
+export declare class DashEngine extends BaseEngine {
+    private driver;
+    private dvrErrorHandler;
+    private isIntroPass;
+    private introFallThroughReported;
+    getDriver(): unknown | null;
+    setConfig(config: PlayerConfig): void;
+    setBus(bus: TypedEventBus): void;
+    setVideo(video: HTMLVideoElement): void;
+    protected onAttach(): Promise<void>;
+    protected onDetach(): void;
+    protected recoverFromStall(attempt: number): void;
+    setQuality(index: number): void;
+    setAudioTrack(index: number): void;
+    setSubtitle(index: number): void;
+    setPlaybackRate(rate: number): void;
+    seekToLive(): void;
+    private init;
+    private registerDriverEvents;
+    /**
+     * Handles a dash.js ERROR event.
+     *
+     * D-04 / G-07-10: always logs, exactly as before (test/engines/dash.test.ts:619
+     * and :1156 assert this unchanged). On the intro pass only — gated by
+     * this.isIntroPass, computed once in init() from
+     * `Boolean(config.preroll) && this.loadSourceUrl === config.preroll` — a fatal
+     * manifest/segment error stops the stall watchdog and emits `error-fatal`
+     * exactly once (guarded by introFallThroughReported) so
+     * IntroStreamManager.complete() can fire and openMainStream() run instead of
+     * the watchdog reopening the (still intro) lastSrc in a loop. On the main
+     * pass this method only warns — main-stream resilience must stay untouched.
+     */
+    private handleDriverError;
+}
+export {};
+//# sourceMappingURL=dash.d.ts.map

package/dist/build/types/src/engines/dash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dash.d.ts","sourceRoot":"","sources":["../../../../../src/engines/dash.ts"],"names":[],"mappings":"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"}

package/dist/build/types/src/engines/drm.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+import type { EngineSettings } from '../core/config';
+/**
+ * Interface for the CDN token manager used in DRM license requests.
+ * This mirrors the subset of CDNTokenManager methods used by DrmConfigurator.
+ * The full CDNTokenManager class will be ported in a later plan.
+ */
+export interface CDNTokenManagerInterface {
+    extraParamsCallback: ((status?: number) => Promise<Record<string, unknown>>) | null;
+    lastTokenResponse: {
+        extras?: {
+            drm_custom_data?: string;
+        };
+        [key: string]: unknown;
+    } | null;
+    fetchToken: (options: {
+        src: string;
+    }) => Promise<unknown>;
+    isTokenExpired: (expirationTime?: unknown) => boolean;
+}
+export interface DrmConfig {
+    emeEnabled?: boolean;
+    drmSystems?: Record<string, {
+        serverURL?: string;
+        [key: string]: unknown;
+    }>;
+    licenseXhrSetup?: (xhr: XMLHttpRequest, url: string) => Promise<void>;
+}
+export declare class DrmConfigurator {
+    private readonly tokenManager;
+    constructor(tokenManager: CDNTokenManagerInterface | null);
+    /**
+     * 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: EngineSettings): DrmConfig;
+}
+//# sourceMappingURL=drm.d.ts.map

package/dist/build/types/src/engines/drm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drm.d.ts","sourceRoot":"","sources":["../../../../../src/engines/drm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,mBAAmB,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;IACnF,iBAAiB,EAAE;QAAE,MAAM,CAAC,EAAE;YAAE,eAAe,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI,CAAA;IAC3F,UAAU,EAAE,CAAC,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC1D,cAAc,EAAE,CAAC,cAAc,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;CACtD;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,CAAA;IAC3E,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACtE;AAoBD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAiC;gBAElD,YAAY,EAAE,wBAAwB,GAAG,IAAI;IAIzD;;;;;OAKG;IACH,cAAc,CAAC,cAAc,EAAE,cAAc,GAAG,SAAS;CAqC1D"}

package/dist/build/types/src/engines/hls-discontinuity-patch.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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).
+ */
+interface HlsFragment {
+    cc: number;
+}
+interface HlsFragmentHint {
+    cc: number;
+}
+interface HlsLevelDetails {
+    endCC: number;
+    fragments?: HlsFragment[];
+    fragmentHint?: HlsFragmentHint;
+}
+interface HlsLevel {
+    details: HlsLevelDetails;
+}
+interface HlsLike {
+    trigger: (event: string, eventObject?: unknown) => unknown;
+    currentLevel: number;
+    levels?: HlsLevel[];
+}
+interface HlsEvents {
+    AUDIO_TRACK_LOADED: string;
+}
+export declare function applyDiscontinuityWorkaround(driver: HlsLike, hlsEvents: HlsEvents): void;
+export {};
+//# sourceMappingURL=hls-discontinuity-patch.d.ts.map

package/dist/build/types/src/engines/hls-discontinuity-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hls-discontinuity-patch.d.ts","sourceRoot":"","sources":["../../../../../src/engines/hls-discontinuity-patch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,UAAU,WAAW;IACnB,EAAE,EAAE,MAAM,CAAA;CACX;AAED,UAAU,eAAe;IACvB,EAAE,EAAE,MAAM,CAAA;CACX;AAED,UAAU,eAAe;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,WAAW,EAAE,CAAA;IACzB,YAAY,CAAC,EAAE,eAAe,CAAA;CAC/B;AAED,UAAU,QAAQ;IAChB,OAAO,EAAE,eAAe,CAAA;CACzB;AAED,UAAU,OAAO;IACf,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;IAC1D,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAA;CACpB;AAED,UAAU,SAAS;IACjB,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI,CA2BxF"}

package/dist/build/types/src/engines/hls.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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).
+ */
+import { BaseEngine } from './base-engine';
+import { CDNTokenManager } from './cdn-token-manager';
+export declare class HlsEngine extends BaseEngine {
+    private driver;
+    private tokenManager;
+    private autoQuality;
+    private eventState;
+    getDriver(): unknown | null;
+    /**
+     * Returns the CDN token manager used by this engine.
+     * Allows the snapshot handler to share the same manager (avoids duplicate token requests).
+     * Returns null when no token URL is configured or before init().
+     */
+    getTokenManager(): CDNTokenManager | null;
+    protected onAttach(): Promise<void>;
+    protected onDetach(): void;
+    protected recoverFromStall(attempt: number): void;
+    setQuality(index: number): void;
+    setAudioTrack(index: number): void;
+    setSubtitle(index: number): void;
+    setPlaybackRate(rate: number): void;
+    private liveSyncDisabled;
+    seek(time: number): void;
+    seekToLive(): void;
+    /**
+     * Check whether this engine was detached during an async gap.
+     * Used after every await in init() to prevent zombie drivers.
+     */
+    private get detached();
+    private init;
+    private registerDriverEvents;
+    private _onManifestLoaded;
+    private _onLevelLoaded;
+    private _onLevelSwitched;
+    private _onAudioTracksUpdated;
+    private _onAudioTrackSwitched;
+    private _onSubtitleTracksUpdated;
+    private _onSubtitleTrackSwitch;
+}
+//# sourceMappingURL=hls.d.ts.map

package/dist/build/types/src/engines/hls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hls.d.ts","sourceRoot":"","sources":["../../../../../src/engines/hls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE1C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AA2JrD,qBAAa,SAAU,SAAQ,UAAU;IAEvC,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,YAAY,CAA+B;IACnD,OAAO,CAAC,WAAW,CAAO;IAE1B,OAAO,CAAC,UAAU,CAA2B;IAE7C,SAAS,IAAI,OAAO,GAAG,IAAI;IAI3B;;;;OAIG;IACH,eAAe,IAAI,eAAe,GAAG,IAAI;cAQzB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAezC,SAAS,CAAC,QAAQ,IAAI,IAAI;IAkB1B,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAgBjD,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAa/B,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKlC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKhC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKnC,OAAO,CAAC,gBAAgB,CAAQ;IAEvB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAajC,UAAU,IAAI,IAAI;IAWlB;;;OAGG;IACH,OAAO,KAAK,QAAQ,GAEnB;YAEa,IAAI;IAyRlB,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,iBAAiB;IAezB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,wBAAwB;IAahC,OAAO,CAAC,sBAAsB;CAM/B"}

package/dist/build/types/src/engines/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Engine Layer Barrel Export
+ *
+ * Public API for all engine modules.
+ * Import from 'eb-player/engines' or from src/engines/index.ts.
+ *
+ * Tree-shaking note: engines are separate from src/core/index.ts to keep
+ * streaming library integrations (hls.js, dash.js) out of the core bundle.
+ */
+export { BaseEngine } from './base-engine';
+export { HlsEngine } from './hls';
+export { DashEngine } from './dash';
+export { loadScript } from './cdn-loader';
+export { CDNTokenManager } from './cdn-token-manager';
+export { StallWatchdog } from './stall-watchdog';
+export { DrmConfigurator } from './drm';
+export { handleHlsRetry } from './retry/hls';
+export { applyDashRetrySettings } from './retry/dash';
+export { applyDiscontinuityWorkaround } from './hls-discontinuity-patch';
+export { createPosterHandler } from './poster/hls';
+export { createIosHandler } from './ios/hls';
+export { createHlsAbrController } from './abr/hls';
+export { createDashAbrRule } from './abr/dash';
+export { HlsSnapshotHandler } from './snapshot/hls';
+export { DashSnapshotHandler } from './snapshot/dash';
+//# sourceMappingURL=index.d.ts.map

package/dist/build/types/src/engines/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/engines/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,OAAO,CAAA;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAA;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/build/types/src/engines/ios/hls.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+interface IosHandlerData {
+    duration?: number;
+}
+interface IosHandler {
+    data: IosHandlerData;
+    destroy: () => void;
+}
+export declare function createIosHandler(src: string): IosHandler;
+export {};
+//# sourceMappingURL=hls.d.ts.map

package/dist/build/types/src/engines/ios/hls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hls.d.ts","sourceRoot":"","sources":["../../../../../../src/engines/ios/hls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,UAAU,cAAc;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,UAAU,UAAU;IAClB,IAAI,EAAE,cAAc,CAAA;IACpB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CA2CxD"}

package/dist/build/types/src/engines/poster/hls.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+interface HlsMediaElement {
+    play: () => void;
+    pause: () => void;
+}
+interface HlsInstance {
+    loadSource: (src: string) => void;
+    attachMedia: (element: HTMLElement) => void;
+    detachMedia?: () => void;
+    destroy?: () => void;
+    media: HlsMediaElement;
+}
+interface HlsConstructor {
+    new (): HlsInstance;
+}
+interface AttachOptions {
+    src: string;
+    container: HTMLElement;
+    Hls: HlsConstructor;
+}
+interface PosterHandler {
+    attach: (options: AttachOptions) => void;
+    close: () => void;
+    play: () => void;
+    pause: () => void;
+}
+export declare function createPosterHandler(): PosterHandler;
+export {};
+//# sourceMappingURL=hls.d.ts.map

package/dist/build/types/src/engines/poster/hls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hls.d.ts","sourceRoot":"","sources":["../../../../../../src/engines/poster/hls.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,UAAU,WAAW;IACnB,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,WAAW,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAA;IAC3C,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,KAAK,EAAE,eAAe,CAAA;CACvB;AAED,UAAU,cAAc;IACtB,QAAO,WAAW,CAAA;CACnB;AAED,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,WAAW,CAAA;IACtB,GAAG,EAAE,cAAc,CAAA;CACpB;AAED,UAAU,aAAa;IACrB,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAA;IACxC,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,wBAAgB,mBAAmB,IAAI,aAAa,CA6BnD"}

package/dist/build/types/src/engines/retry/dash.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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.
+ */
+interface DashDriverLike {
+    updateSettings: (settings: DashSettings) => void;
+}
+interface DashRetryIntervals {
+    MPD: number;
+    XLinkExpansion: number;
+    InitializationSegment: number;
+    IndexSegment: number;
+    MediaSegment: number;
+    BitstreamSwitchingSegment: number;
+    other: number;
+    lowLatencyReductionFactor: number;
+}
+interface DashRetryAttempts {
+    MPD: number;
+    XLinkExpansion: number;
+    InitializationSegment: number;
+    IndexSegment: number;
+    MediaSegment: number;
+    BitstreamSwitchingSegment: number;
+    other: number;
+    lowLatencyMultiplyFactor: number;
+}
+interface DashSettings {
+    streaming: {
+        retryIntervals?: DashRetryIntervals;
+        retryAttempts?: DashRetryAttempts;
+    };
+}
+export interface DashRetryOptions {
+    /**
+     * True when these settings are being applied for the intro (preroll)
+     * pass rather than the main stream. The intro is discarded on failure,
+     * so there is no value in retrying it for long — HLS gives up on the
+     * FIRST fatal intro error (src/engines/retry/hls.ts:88-94), so bounding
+     * the DASH intro to a couple of attempts is already the more forgiving
+     * of the two engines. Main-stream resilience (retryAttempts: Infinity)
+     * is untouched because the bound only applies when this flag is set.
+     */
+    introPass?: boolean;
+}
+export declare function applyDashRetrySettings(driver: DashDriverLike, options?: DashRetryOptions): void;
+export {};
+//# sourceMappingURL=dash.d.ts.map

package/dist/build/types/src/engines/retry/dash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dash.d.ts","sourceRoot":"","sources":["../../../../../../src/engines/retry/dash.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,UAAU,cAAc;IACtB,cAAc,EAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI,CAAA;CACjD;AAED,UAAU,kBAAkB;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,cAAc,EAAE,MAAM,CAAA;IACtB,qBAAqB,EAAE,MAAM,CAAA;IAC7B,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,yBAAyB,EAAE,MAAM,CAAA;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,yBAAyB,EAAE,MAAM,CAAA;CAClC;AAED,UAAU,iBAAiB;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,cAAc,EAAE,MAAM,CAAA;IACtB,qBAAqB,EAAE,MAAM,CAAA;IAC7B,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,yBAAyB,EAAE,MAAM,CAAA;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,wBAAwB,EAAE,MAAM,CAAA;CACjC;AAED,UAAU,YAAY;IACpB,SAAS,EAAE;QACT,cAAc,CAAC,EAAE,kBAAkB,CAAA;QACnC,aAAa,CAAC,EAAE,iBAAiB,CAAA;KAClC,CAAA;CACF;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAUD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,GAAE,gBAAqB,GAAG,IAAI,CA8BnG"}

package/dist/build/types/src/engines/retry/hls.d.ts

@@ -0,0 +1,47 @@
+/**
+ * HLS retry handler.
+ *
+ * Registers an hlsError listener on the hls.js driver and attempts
+ * automatic recovery:
+ * - Fatal mediaError: calls recoverMediaError() after 1s
+ * - Fatal keySystemError: unrecoverable (e.g. no HTTPS for DRM) — no retry
+ * - Fatal other error (intro pass): calls onFatalNetworkError() to fall through to main
+ * - Fatal other error (main pass): calls startLoad() after 1s (keeps retrying)
+ * - Non-fatal error: re-checks after 3s; if currentTime has not advanced
+ *   (and Chromecast is not casting), applies the same recovery
+ *
+ * Non-fatal retries are capped to prevent infinite loops (e.g. keyLoadError
+ * where startLoad() triggers the same failing key request repeatedly).
+ * After the cap is reached, further events for that error are silently ignored.
+ */
+interface HlsDriverLike {
+    on: (event: string, handler: (event: string, data: HlsErrorData) => void) => void;
+    media: {
+        currentTime: number;
+    } | null;
+    recoverMediaError: () => void;
+    startLoad: (startPosition?: number) => void;
+}
+interface HlsErrorData {
+    fatal: boolean;
+    type: string;
+    details?: string;
+}
+interface EngineContext {
+    chromecast_casting?: boolean;
+    onUnrecoverableError?: (message: string) => void;
+    /**
+     * Called once when a fatal non-unrecoverable error occurs and the caller
+     * wants to give up rather than loop startLoad(). Intended for the intro
+     * pass so the player falls through to the main stream instead of retrying
+     * a permanently-unreachable intro manifest forever.
+     *
+     * When this callback is set, the fatal non-media/non-unrecoverable branch
+     * calls it and returns immediately (no startLoad loop). When absent the
+     * original retry-forever behavior is preserved (main stream resilience).
+     */
+    onFatalNetworkError?: (errorKey: string) => void;
+}
+export declare function handleHlsRetry(driver: HlsDriverLike, engine?: EngineContext): void;
+export {};
+//# sourceMappingURL=hls.d.ts.map

package/dist/build/types/src/engines/retry/hls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hls.d.ts","sourceRoot":"","sources":["../../../../../../src/engines/retry/hls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,UAAU,aAAa;IACrB,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,KAAK,IAAI,KAAK,IAAI,CAAA;IACjF,KAAK,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IACrC,iBAAiB,EAAE,MAAM,IAAI,CAAA;IAC7B,SAAS,EAAE,CAAC,aAAa,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAC5C;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,aAAa;IACrB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAChD;;;;;;;;;OASG;IACH,mBAAmB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CACjD;AAQD,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,IAAI,CAmFlF"}

package/dist/build/types/src/engines/segment-token-loader.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Segment (fragment) CDN token signing — shared primitive.
+ *
+ * Extends CDN token signing from manifests to segments, behind an opt-in flag
+ * (`EngineSettings.signSegmentsWithCdnToken`). Each segment is signed with the
+ * grant carried by its OWN parent playlist — read from `context.frag.baseurl`,
+ * the object hls.js itself parsed that fragment from — never from any store,
+ * cache, or shared manager state. This makes cross-rendition mis-signing
+ * structurally impossible rather than merely unlikely.
+ *
+ * CRITICAL: this module must never acquire or refresh a token. It only reads
+ * data already present on the fragment context handed to it by hls.js. Any
+ * acquisition call here would reintroduce the single-slot cache reuse in
+ * `CDNTokenManager.lastTokenResponse`, which hands one rendition's grant to
+ * another — the exact failure this design forbids.
+ *
+ * Token expiry model (CDN-04, D-07): a segment carries whatever grant its
+ * parent playlist carried when hls.js parsed it. Live playlists reload on
+ * their own cadence, so their fragments pick up refreshed grants with no
+ * refresh machinery here — reload IS the refresh path. VOD playlists are
+ * parsed exactly once by hls.js 1.6.10 (its level controller only
+ * (re)requests a playlist it has none of, or one that is live), so a VOD
+ * asset's segment grants are frozen at first parse for the asset's entire
+ * duration. If a token's lifetime is shorter than the asset's duration, later
+ * segments will be rejected by the edge and surface through the existing
+ * error/retry path. This is an accepted operational constraint — the token
+ * service's lifetime must exceed the longest VOD asset — not an oversight;
+ * D-07 chose reload-cadence refresh and CONTEXT.md defers a proactive
+ * near-expiry refresh path with a named revisit condition (a real asset shown
+ * to outlive its grant). No timer, interval, or scheduled re-fetch belongs in
+ * this module.
+ */
+import type { TokenType } from './cdn-token-manager';
+export interface SegmentLoaderFrag {
+    baseurl?: string;
+}
+export interface SegmentLoaderContext {
+    url: string;
+    frag?: SegmentLoaderFrag;
+}
+/**
+ * Structural shape of hls.js's `LoaderStats`, the 4th argument its own
+ * `FragmentLoader`-wired `onError` closure reads. Only the fields this
+ * module needs to construct a well-formed (all-zero) stats object for the
+ * fail-loud path below — narrowed the same way the rest of this module's
+ * types are narrowed from the real hls.js 1.6.10 interfaces.
+ */
+export interface SegmentLoaderStats {
+    aborted: boolean;
+    loaded: number;
+    total: number;
+    retry: number;
+    chunkCount: number;
+    bwEstimate: number;
+    loading: {
+        start: number;
+        first: number;
+        end: number;
+    };
+    parsing: {
+        start: number;
+        end: number;
+    };
+    buffering: {
+        start: number;
+        first: number;
+        end: number;
+    };
+}
+export interface SegmentLoaderCallbacks {
+    onSuccess: (response: unknown, stats: unknown, context: unknown) => void;
+    onError: (error: unknown, context: unknown, response: unknown, stats: SegmentLoaderStats) => void;
+    onTimeout: (stats: unknown, context: unknown, response: unknown) => void;
+}
+export interface SegmentLoaderConfig {
+    [key: string]: unknown;
+}
+export interface SegmentLoaderClass {
+    new (config: SegmentLoaderConfig): {
+        load: (context: SegmentLoaderContext, config: SegmentLoaderConfig, callbacks: SegmentLoaderCallbacks) => void;
+    };
+}
+/**
+ * The only thing the loader reads from the token manager: its readonly token
+ * type. Kept structural (not an import of the class) so both engines and both
+ * test suites can satisfy it without constructing a real manager.
+ */
+export interface SegmentSigningTokenSource {
+    readonly tokenType: TokenType | undefined;
+}
+export declare const SEGMENT_SIGNING_TOKEN_TYPES: readonly TokenType[];
+/**
+ * Builds the single diagnostic string used for every unsupported-token-type
+ * case. Names the flag and the offending token type (or says none is
+ * configured) and lists the supported ones. Never includes a token value.
+ */
+export declare function segmentSigningUnsupportedMessage(tokenType: TokenType | undefined): string;
+/**
+ * Pure transfer: reads `token`, `expires` and `token_path` off the parent
+ * playlist URL's query string and reapplies them to the segment URL via the
+ * same static primitive that signs manifests, so a signed segment URL is
+ * shaped exactly like a signed manifest URL. Returns the segment URL
+ * unchanged when the playlist carries no token, or when either URL cannot be
+ * parsed (a thrown exception inside a loader is a dead player, not a signing
+ * failure).
+ */
+export declare function signSegmentUrlFromPlaylist(segmentUrl: string, parentPlaylistUrl: string): string;
+/**
+ * Returns a loader class extending `BaseLoader`, built exactly like the
+ * existing playlist loader: call `super()`, bind the inherited `load`, then
+ * assign an own `load` property that reads `context.frag?.baseurl`.
+ *
+ * `tokenSource` is captured by closure — never stored on `this` and never
+ * used to acquire or refresh a token.
+ */
+export declare function createSegmentTokenLoaderClass(BaseLoader: SegmentLoaderClass, tokenSource: SegmentSigningTokenSource): SegmentLoaderClass;
+//# sourceMappingURL=segment-token-loader.d.ts.map

package/dist/build/types/src/engines/segment-token-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-token-loader.d.ts","sourceRoot":"","sources":["../../../../../src/engines/segment-token-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAOpD,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,iBAAiB,CAAA;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACtD,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACvC,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CACzD;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IACxE,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAA;IACjG,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAA;CACzE;AAED,MAAM,WAAW,mBAAmB;IAClC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,MAAM,EAAE,mBAAmB,GAAG;QACjC,IAAI,EAAE,CAAC,OAAO,EAAE,oBAAoB,EAAE,MAAM,EAAE,mBAAmB,EAAE,SAAS,EAAE,sBAAsB,KAAK,IAAI,CAAA;KAC9G,CAAA;CACF;AAED;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAAA;CAC1C;AAQD,eAAO,MAAM,2BAA2B,EAAE,SAAS,SAAS,EAI1D,CAAA;AAEF;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAIzF;AAwBD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAahG;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,kBAAkB,EAC9B,WAAW,EAAE,yBAAyB,GACrC,kBAAkB,CAgDpB"}

package/dist/build/types/src/engines/snapshot/dash.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+interface DashPlayerInstance {
+    initialize: (element: HTMLVideoElement, src: string, autoplay: boolean) => void;
+    updateSettings: (settings: Record<string, unknown>) => void;
+    on: (event: string, handler: (data?: unknown) => void) => void;
+    off: (event: string, handler: (data?: unknown) => void) => void;
+    setMute: (muted: boolean) => void;
+    seek: (time: number) => void;
+    isPaused: () => boolean;
+    play: () => void;
+    pause: () => void;
+    reset: () => void;
+}
+interface DashPlayerFactory {
+    (): {
+        create: () => DashPlayerInstance;
+    };
+    events: Record<string, string>;
+}
+export interface DashjsForSnapshot {
+    MediaPlayer: DashPlayerFactory;
+}
+export interface SnapshotHandle {
+    take: (time: number) => void;
+    destroy: () => void;
+    video: HTMLVideoElement;
+}
+export declare class DashSnapshotHandler {
+    private readonly src;
+    private player;
+    private offscreenVideo;
+    private ready;
+    constructor(src: string);
+    /**
+     * 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: DashjsForSnapshot): Promise<SnapshotHandle>;
+    /**
+     * Reset and destroy the snapshot player and remove the off-screen video element.
+     */
+    destroy(): void;
+    private cleanup;
+}
+export {};
+//# sourceMappingURL=dash.d.ts.map