movi-player 0.3.0 → 0.3.2

package/dist/core/MoviPlayer.js

@@ -2,7 +2,7 @@
  * MoviPlayer - Main public API for the streaming video library
  */
 import { EventEmitter } from "../events/EventEmitter";
-import { HttpSource, FileSource, ThumbnailHttpSource, EncryptedHttpSource, } from "../source";
+import { HttpSource, FileSource, ThumbnailHttpSource, EncryptedHttpSource, analyzeDashFallback, } from "../source";
 import { LRUCache } from "../cache";
 import { Demuxer } from "../demux";
 import { TrackManager } from "./TrackManager";
@@ -16,7 +16,9 @@ import { CanvasRenderer } from "../render/CanvasRenderer";
 import { AudioRenderer } from "../render/AudioRenderer";
 import { updateAllBindingsLogLevel, ThumbnailBindings } from "../wasm/bindings";
 import { loadWasmModuleNew } from "../wasm/FFmpegLoader";
+import { ShakaPlayerWrapper } from "../render/ShakaPlayerWrapper";
 import { HLSPlayerWrapper } from "../render/HLSPlayerWrapper";
+import { DASHPlayerWrapper } from "../render/DASHPlayerWrapper";
 import { ThumbnailRenderer } from "../utils/ThumbnailRenderer";
 const TAG = "MoviPlayer";
 export class MoviPlayer extends EventEmitter {
@@ -45,6 +47,16 @@ export class MoviPlayer extends EventEmitter {
     demuxer = null;
     // Separate audio source — uses native <audio> element (zero WASM overhead)
     nativeAudioEl = null;
+    // When custom media headers are set, the native <audio> can't send them, so
+    // we fetch the file ourselves and feed it a blob: URL. Track the logical
+    // (pre-blob) URL for same-source detection and the object URL for revocation.
+    _nativeAudioObjectUrl = null;
+    _nativeAudioLogicalUrl = null;
+    // Set when autoplay-with-sound was blocked for the native <audio> track and we
+    // fell back to muted playback. Surfaces via isAudioBlockedSuspended() so the
+    // element shows the "Tap to unmute" pill (mirrors the WebAudio path). Cleared
+    // on a successful unmuted play or when the user unmutes.
+    _nativeAudioAutoplayBlocked = false;
     _audioTracks = [];
     _activeAudioLang = "";
     // External subtitle tracks (VTT/SRT)
@@ -61,6 +73,9 @@ export class MoviPlayer extends EventEmitter {
     previewsAllowed() {
         if (!this.config.enablePreviews)
             return false;
+        // Non-range sources keep previews ON: the thumbnail source borrows frames
+        // straight from the main source's RAM window (no network), so previews work
+        // for any position inside the buffered/seekable range.
         // NOTE: a file-size cap used to live here — the seek-bar thumbnail
         // pipeline opens a SECOND isolated WASM module + FFmpeg context, and on
         // large 1 GB+ sources the two heaps can exhaust the tab's memory budget,
@@ -75,6 +90,20 @@ export class MoviPlayer extends EventEmitter {
             return false;
         return true;
     }
+    /** Proxy a stream wrapper's events + mirror its TrackManager onto the player. */
+    wireStreamWrapper(wrapper) {
+        const events = [
+            "loadStart", "loadEnd", "play", "pause", "ended", "timeUpdate",
+            "durationChange", "stateChange", "error", "buffering", "seeking", "seeked",
+        ];
+        events.forEach((evt) => {
+            // @ts-ignore — event names line up across the wrapper and player maps
+            wrapper.on(evt, (arg) => this.emit(evt, arg));
+        });
+        wrapper.trackManager.on("tracksChange", (tracks) => {
+            this.trackManager.setTracks(tracks);
+        });
+    }
     // Decoders and Renderers
     videoDecoder;
     audioDecoder;
@@ -89,8 +118,10 @@ export class MoviPlayer extends EventEmitter {
     // Extracted once at load time when the demuxer reports an attached_pic
     // pseudo-stream; null for plain video files or audio without artwork.
     coverArt = null;
-    // HLS Wrapper
-    hlsWrapper = null;
+    // Active adaptive-streaming wrapper (Shaka primary, hls.js/dash.js fallback).
+    // Non-null only while a stream source is active; delegation throughout the
+    // player stays format-agnostic.
+    streamWrapper = null;
     // Preview pipeline (C-based FFmpeg software decoding)
     thumbnailBindings = null;
     thumbnailSource = null;
@@ -99,8 +130,15 @@ export class MoviPlayer extends EventEmitter {
     isPreviewGenerating = false;
     audioRenderer;
     previewInitPromise = null; // Guard for preview initialization
+    previewInitAttempts = 0; // Bounded retries for preview pipeline init
+    previewInitGaveUp = false; // Stop retrying once init has failed too often
     // Debug flag to disable audio processing
     disableAudio = false; // Set to true to disable audio for debugging
+    // Audio-only mode (data-saver): skip video decoding to save CPU (the
+    // demuxer still reads the interleaved bytes, but decode is the expensive
+    // part); for adaptive streams the wrapper also drops the video renditions to
+    // save bandwidth. The UI switches to the album-art / strip surface.
+    _audioOnly = false;
     muted = false; // Mute state
     wasPlayingBeforeRebuffer = false; // Track if we were playing before entering rebuffering state
     _stallStartTime = 0; // When stall was first detected
@@ -175,6 +213,7 @@ export class MoviPlayer extends EventEmitter {
     constructor(config) {
         super();
         this.config = config;
+        this._audioOnly = !!config.audioOnly;
         this.cache = new LRUCache(config.cache?.maxSizeMB ?? 100);
         this.trackManager = new TrackManager();
         this.clock = new Clock();
@@ -409,63 +448,119 @@ export class MoviPlayer extends EventEmitter {
         this.coverArt = null;
         // Clean up any existing preview pipeline
         this.destroyPreviewPipeline();
-        // Check for HLS — only when caller used SourceConfig. A custom
-        // SourceAdapter bypasses URL/HLS detection entirely.
+        // Adaptive streaming — only when the caller used SourceConfig (a custom
+        // SourceAdapter bypasses URL detection entirely). HLS (.m3u8) and DASH
+        // (.mpd) both go through Shaka Player (one engine, MSE under the hood). This
+        // covers multiplexed DASH too — Shaka plays it natively, so there's no
+        // FFmpeg fallback to fork on here.
         const src = this.config.source;
-        if (!this.config.sourceAdapter &&
-            src &&
-            src.type === "url" &&
-            src.url &&
-            (src.url.includes(".m3u8") || src.url.toLowerCase().endsWith("m3u8"))) {
-            Logger.info(TAG, "Detected HLS stream, switching to HLSPlayerWrapper");
-            this.hlsWrapper = new HLSPlayerWrapper(this.config);
-            // Proxy events
-            const events = [
-                "loadStart",
-                "loadEnd",
-                "play",
-                "pause",
-                "ended",
-                "timeUpdate",
-                "durationChange",
-                "stateChange",
-                "error",
-                "buffering",
-                "seeking",
-                "seeked",
-            ];
-            events.forEach((evt) => {
-                // @ts-ignore
-                this.hlsWrapper.on(evt, (arg) => this.emit(evt, arg));
+        const streamUrl = !this.config.sourceAdapter && src && src.type === "url" && src.url
+            ? src.url
+            : null;
+        const lowerUrl = streamUrl?.toLowerCase() ?? "";
+        // HLS (.m3u8), DASH (.mpd), and Smooth Streaming (.ism/.isml) all go
+        // through Shaka. `.ism` also matches `.isml/manifest`.
+        const isStream = !!streamUrl &&
+            (lowerUrl.includes(".m3u8") ||
+                lowerUrl.includes(".mpd") ||
+                lowerUrl.includes(".ism"));
+        if (isStream) {
+            const isHls = lowerUrl.includes(".m3u8");
+            const isDash = lowerUrl.includes(".mpd");
+            const kind = isHls ? "HLS" : lowerUrl.includes(".ism") ? "Smooth Streaming" : "DASH";
+            // Forward track selections from the main TrackManager to whichever stream
+            // wrapper is currently active (added once; resolves the live field).
+            this.trackManager.on("videoTrackChange", (track) => {
+                this.streamWrapper?.selectVideoTrack(track ? track.id : -1);
             });
-            // Special handling for tracks to integrate with TrackManager?
-            // HLSWrapper has its own TrackManager. We might need to expose it or sync it.
-            // For now, let's swap the trackManager so external API calls work naturally.
-            // Sync tracks from HLS wrapper to main track manager
-            this.hlsWrapper.trackManager.on("tracksChange", (tracks) => {
-                this.trackManager.setTracks(tracks);
+            this.trackManager.on("audioTrackChange", (track) => {
+                if (track)
+                    this.streamWrapper?.selectAudioTrack(track.id);
             });
-            // Forward track selection from main track manager to HLS wrapper
-            this.trackManager.on("videoTrackChange", (track) => {
-                if (this.hlsWrapper) {
-                    this.hlsWrapper.selectVideoTrack(track ? track.id : -1);
-                }
+            this.trackManager.on("subtitleTrackChange", (track) => {
+                this.streamWrapper?.selectSubtitleTrack(track ? track.id : null);
             });
+            // --- Tier 1: Shaka (HLS + DASH + MSS + muxed). ---
             try {
-                await this.hlsWrapper.load();
-                this.stateManager.setState("ready"); // Sync local state manager just in case
+                const shaka = new ShakaPlayerWrapper(this.config);
+                this.streamWrapper = shaka;
+                this.wireStreamWrapper(shaka);
+                Logger.info(TAG, `Detected ${kind} stream, using ShakaPlayerWrapper`);
+                await shaka.load();
+                this.stateManager.setState("ready");
                 return;
             }
-            catch (e) {
-                this.stateManager.setState("error");
-                throw e;
+            catch (eShaka) {
+                Logger.warn(TAG, `Shaka failed on ${kind} stream`, eShaka);
+                try {
+                    this.streamWrapper?.destroy();
+                }
+                catch { }
+                this.streamWrapper = null;
+                // --- Tier 2: hls.js / dash.js. Their MSE engines play streams Shaka
+                // rejects (e.g. under-specified single-file DASH the browser demuxer
+                // handles but Shaka/FFmpeg won't). ---
+                if (isHls || isDash) {
+                    try {
+                        const fb = isHls
+                            ? new HLSPlayerWrapper(this.config)
+                            : new DASHPlayerWrapper(this.config);
+                        this.streamWrapper = fb;
+                        this.wireStreamWrapper(fb);
+                        Logger.info(TAG, `Shaka failed; retrying with ${isHls ? "hls.js" : "dash.js"}`);
+                        await fb.load();
+                        this.stateManager.setState("ready");
+                        Logger.info(TAG, `Recovered via ${isHls ? "hls.js" : "dash.js"}`);
+                        return;
+                    }
+                    catch (eFallback) {
+                        Logger.warn(TAG, `${isHls ? "hls.js" : "dash.js"} fallback also failed`, eFallback);
+                        try {
+                            this.streamWrapper?.destroy();
+                        }
+                        catch { }
+                        this.streamWrapper = null;
+                    }
+                }
+                // --- Tier 3: FFmpeg demuxer for bare-<BaseURL> single-file DASH that
+                // even the MSE engines refuse (e.g. muxed single-file). Falls through
+                // to the demuxer path below with the video file as the source (+ the
+                // separate audio file as a native-audio source for demuxed content). ---
+                let fellBack = false;
+                if (isDash) {
+                    try {
+                        const plan = await analyzeDashFallback(streamUrl, src?.headers);
+                        if (plan) {
+                            Logger.info(TAG, "Falling back to the FFmpeg demuxer");
+                            this.source = await this.createSource({
+                                type: "url",
+                                url: plan.videoUrl,
+                                headers: src?.headers,
+                            });
+                            if (plan.audioUrl) {
+                                this.config.audioSource = { type: "url", url: plan.audioUrl, headers: src?.headers };
+                            }
+                            fellBack = true; // fall through to the demuxer path below
+                        }
+                    }
+                    catch (eDemux) {
+                        Logger.warn(TAG, "FFmpeg DASH fallback failed", eDemux);
+                    }
+                }
+                if (!fellBack) {
+                    this.stateManager.setState("error");
+                    throw eShaka; // surface the original Shaka error
+                }
             }
         }
         try {
             // Create source — honor a pre-built adapter if the caller supplied
             // one (custom protocol, encrypted blob, IndexedDB-backed source, etc.)
             // so the demuxer can read through it without going through SourceConfig.
-            if (this.config.sourceAdapter) {
+            if (this.source) {
+                // Already resolved (defensive — a prior load may have set it).
+            }
+            else if (this.config.sourceAdapter) {
                 this.source = this.config.sourceAdapter;
             }
             else if (this.config.source) {
@@ -574,6 +669,9 @@ export class MoviPlayer extends EventEmitter {
         if (config.type === "url" && config.url) {
             const maxBufferSizeMB = this.config.cache?.maxSizeMB;
             const source = new HttpSource(config.url, config.headers, maxBufferSizeMB);
+            // Server has no Range support + file too big to cache → forward-only
+            // linear playback. Surface it so the UI can drop the timeline / seeking.
+            source.setOnLinearMode(() => this.emit("linearmode", undefined));
             return source;
         }
         throw new Error("Invalid source configuration");
@@ -691,9 +789,23 @@ export class MoviPlayer extends EventEmitter {
      * renderer starts AudioContext playback the moment samples arrive. Both
      * break if we decode during prebuffer.
      */
+    /**
+     * Native-audio-only playback (split-source data saver): audio-only mode AND a
+     * separate <audio> track. There's no video pipeline to run, and the audio is
+     * its own element, so the demuxer body is never read — only the header it
+     * downloaded at open() — saving the video file's entire bandwidth on top of
+     * the skipped decode. Drives playback straight off the <audio> element.
+     */
+    nativeAudioOnlyPlayback() {
+        return this._audioOnly && !!this.nativeAudioEl;
+    }
     async prebuffer() {
         if (!this.demuxer)
             return;
+        // Native-audio-only: nothing to prebuffer — reading video packets here would
+        // start downloading the body we're trying to skip.
+        if (this.nativeAudioOnlyPlayback())
+            return;
         const hasVideoTrack = !!this.trackManager.getActiveVideoTrack();
         const hasInFileAudio = !!this.trackManager.getActiveAudioTrack() &&
             !this.disableAudio &&
@@ -749,8 +861,8 @@ export class MoviPlayer extends EventEmitter {
      * Start playback
      */
     async play() {
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.play();
+        if (this.streamWrapper) {
+            return this.streamWrapper.play();
         }
         // Stop pause-time buffering — we're resuming active playback
         this.stopPauseBuffering();
@@ -758,6 +870,12 @@ export class MoviPlayer extends EventEmitter {
             Logger.warn(TAG, "Cannot play in current state");
             return;
         }
+        // Native-audio-only (split-source data saver): no demuxer/decode pipeline —
+        // drive playback straight off the <audio> element so the video body is never
+        // fetched. Handles first play, resume, and replay.
+        if (this.nativeAudioOnlyPlayback()) {
+            return this.playNativeAudioOnly();
+        }
         const currentState = this.stateManager.getState();
         // During buffering or seeking, mark intent to resume when ready
         if (currentState === "buffering" || currentState === "seeking") {
@@ -787,6 +905,23 @@ export class MoviPlayer extends EventEmitter {
             this.wasPlayingBeforeSeek = true;
             try {
                 await this.seek(0, { suppressSpinner: true });
+                // The separate native <audio> track ended with the video; seek(0)
+                // rewinds its currentTime but leaves it paused, so the replay plays
+                // silent. Restart it here (the normal play() audio-resume block is
+                // skipped on the wasEnded path). A manual replay is a user gesture so
+                // this succeeds; an auto-loop restart that was never unmuted can still
+                // be blocked — keep the muted-rolling flag so the unmute pill stays.
+                if (this.nativeAudioEl && this.nativeAudioEl.paused) {
+                    this.nativeAudioEl.playbackRate = this.clock.getPlaybackRate();
+                    try {
+                        await this.nativeAudioEl.play();
+                        this._nativeAudioAutoplayBlocked = false;
+                    }
+                    catch (e) {
+                        this._nativeAudioAutoplayBlocked = true;
+                        Logger.warn(TAG, "Native audio replay blocked — rolling video muted", e);
+                    }
+                }
             }
             catch (error) {
                 this.suppressSeekSpinner = false;
@@ -861,7 +996,25 @@ export class MoviPlayer extends EventEmitter {
             // audio context. Running them concurrently let the audio renderer
             // accept the very first decoded packet before the demuxer cursor
             // had finished rewinding.
-            await this.demuxer.seek(targetTime);
+            //
+            // Guard the seek: the demuxer rejects with "error -1" when the source
+            // opened in a degenerate state (e.g. a non-faststart file whose prebuffer
+            // hit EOF with zero frames, or a rapid source-switch that tore down the
+            // read path mid-open). Unguarded, it escaped as an uncaught rejection —
+            // and with the caller re-issuing play() it spammed/looped. Bail cleanly
+            // and mark the source unplayable so the UI can show the broken state
+            // instead of retrying a seek that can never succeed.
+            try {
+                await this.demuxer.seek(targetTime);
+            }
+            catch (error) {
+                Logger.error(TAG, "Demuxer seek on first play failed", error);
+                this.wasPlayingBeforeSeek = false;
+                this.suppressSeekSpinner = false;
+                this.stateManager.setState("error");
+                this.emit("error", error instanceof Error ? error : new Error(String(error)));
+                return;
+            }
             // After Open-GOP recovery (decoder rejected the first keyframe past
             // the seek target and reset), the next decoded frames will begin at
             // the previous GOP's keyframe — often 1-2s behind targetTime. Without
@@ -914,17 +1067,22 @@ export class MoviPlayer extends EventEmitter {
             this.nativeAudioEl.playbackRate = this.clock.getPlaybackRate();
             try {
                 await this.nativeAudioEl.play();
+                this._nativeAudioAutoplayBlocked = false;
             }
             catch {
-                Logger.warn(TAG, "Native audio play blocked — staying paused for user gesture");
-                if (!this.disableAudio)
-                    this.audioRenderer.pause();
-                if (this.videoRenderer)
-                    this.videoRenderer.stopPresentationLoop();
-                if (this.stateManager.getState() !== "paused") {
-                    this.stateManager.setState("paused");
-                }
-                return;
+                // Autoplay-with-sound was blocked (no user gesture yet). A bare <audio>
+                // element won't autoplay even when muted (Chrome's muted-autoplay
+                // allowance is really for <video>), so we can't start its audio yet —
+                // but the VIDEO lives on the canvas and needs no autoplay permission.
+                // Roll the video on the wall clock (while the element is paused the
+                // clock's audio provider returns -1, so it falls back automatically),
+                // flag the block, and let the element surface the "Tap to unmute" pill.
+                // The unmute gesture (setMuted(false)) then seeks + plays the audio,
+                // which re-assumes clock-master duty. Mirrors the WebAudio/in-file path,
+                // where video rolls while the AudioContext stays suspended.
+                Logger.warn(TAG, "Native audio autoplay blocked — rolling video muted (tap to unmute)");
+                this._nativeAudioAutoplayBlocked = true;
+                // Fall through — do NOT pause or stop the presentation loop.
             }
         }
         this.clock.start();
@@ -955,12 +1113,54 @@ export class MoviPlayer extends EventEmitter {
         this.processLoop();
         Logger.info(TAG, "Playing");
     }
+    /**
+     * Play in native-audio-only mode (split-source data saver). No demuxer reads,
+     * no decode loop — just the <audio> element + clock. Handles first play,
+     * resume, and replay (rewind on ended). Autoplay-blocked stays paused (there's
+     * no video to roll), with the centre play button as the resume affordance.
+     */
+    async playNativeAudioOnly() {
+        const audioEl = this.nativeAudioEl;
+        if (!audioEl)
+            return;
+        this.requestWakeLock();
+        // Replay: rewind the audio + clock before starting again.
+        if (this.stateManager.getState() === "ended") {
+            try {
+                audioEl.currentTime = 0;
+                this.clock.seek(this.startTime);
+            }
+            catch { }
+            this.stateManager.setState("seeking"); // ended → seeking (valid)
+        }
+        audioEl.playbackRate = this.clock.getPlaybackRate();
+        try {
+            await audioEl.play();
+            this._nativeAudioAutoplayBlocked = false;
+        }
+        catch {
+            // Autoplay-with-sound blocked and there's no video to roll muted — stay
+            // paused so the centre play button shows for a user gesture.
+            Logger.warn(TAG, "Native audio autoplay blocked — staying paused for user gesture");
+            const st = this.stateManager.getState();
+            if (st !== "paused")
+                this.stateManager.setState("paused");
+            return;
+        }
+        this.clock.start();
+        this._playStartTime = performance.now();
+        const st = this.stateManager.getState();
+        if (st === "ready" || st === "paused" || st === "seeking") {
+            this.stateManager.setState("playing");
+        }
+        Logger.info(TAG, "Playing (native-audio-only)");
+    }
     /**
      * Pause playback
      */
     pause() {
-        if (this.hlsWrapper) {
-            this.hlsWrapper.pause();
+        if (this.streamWrapper) {
+            this.streamWrapper.pause();
             return;
         }
         if (!this.stateManager.canPause()) {
@@ -1699,6 +1899,14 @@ export class MoviPlayer extends EventEmitter {
                     const activeVideo = this.trackManager.getActiveVideoTrack();
                     const activeAudio = this.trackManager.getActiveAudioTrack();
                     if (activeVideo && activeVideo.id === packet.streamIndex) {
+                        // Audio-only mode: skip ALL video decoding to save CPU. Decode is
+                        // the expensive part; the interleaved bytes still arrive (no single-
+                        // file bandwidth saving — that's the adaptive-stream wrapper's job),
+                        // but the GPU/CPU video pipeline stays idle. Toggling back to video
+                        // re-seeks to recover a keyframe (see setAudioOnly).
+                        if (this._audioOnly) {
+                            continue;
+                        }
                         // In background (not PiP), skip video decoding entirely.
                         // This prevents frame queue buildup that blocks audio demuxing via backpressure.
                         // At 60fps, video queue fills in ~1.7s and starves audio.
@@ -1941,8 +2149,26 @@ export class MoviPlayer extends EventEmitter {
     // cleared on seek completion (notifySeekCompletion).
     suppressSeekSpinner = false;
     async seek(seconds, opts) {
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.seek(seconds);
+        if (this.streamWrapper) {
+            return this.streamWrapper.seek(seconds);
+        }
+        // Native-audio-only (split-source data saver): no demuxer/decoder pipeline —
+        // just move the <audio> element and the clock. No demuxer.seek (which would
+        // start reading the video body we're skipping).
+        if (this.nativeAudioOnlyPlayback() && this.nativeAudioEl) {
+            const t = Math.max(0, Math.min(seconds, this.getDuration() || seconds));
+            try {
+                this.nativeAudioEl.currentTime = t;
+            }
+            catch { }
+            this.clock.seek(t + this.startTime);
+            this.seekKeyframeOffset = 0;
+            this.eofReached = false;
+            this.eofSince = 0;
+            this.emit("seeking", t);
+            this.emit("timeUpdate", t);
+            this.emit("seeked", t);
+            return;
         }
         // A genuine user seek (no opt) clears any leftover suppression so its
         // spinner shows; play()-initiated seeks pass suppressSpinner to hide it.
@@ -2159,10 +2385,18 @@ export class MoviPlayer extends EventEmitter {
      * Generates a preview frame for the given time using C for demuxing and WebCodecs for decoding.
      */
     async getPreviewFrame(time) {
+        if (this._audioOnly)
+            return null; // Data-saver: never decode video for previews
         if (!this.previewsAllowed())
             return null; // Disabled, or source too large for a 2nd WASM context
-        if (this.hlsWrapper)
-            return null; // Previews not supported for HLS
+        // Adaptive streams: use the manifest's own thumbnail track via Shaka
+        // (DASH-IF tiled thumbnails / HLS image playlists). Returns null when the
+        // manifest has no thumbnail track, so the preview just stays hidden — far
+        // cheaper than the FFmpeg path, which can't byte-range-seek a stream.
+        if (this.streamWrapper)
+            return this.streamWrapper.getThumbnailBlob?.(time) ?? null;
+        if (this.previewInitGaveUp)
+            return null; // Init failed repeatedly — stop retrying (and re-loading WASM)
         if (this.isPreviewGenerating)
             return null; // Busy
         // Audio-only sources have no video track to thumbnail. Bail early
@@ -2184,8 +2418,15 @@ export class MoviPlayer extends EventEmitter {
                         this.previewInitPromise = null;
                     }
                 }
-                // If still no bindings (init failed or promise was cleared), retry
+                // If still no bindings (init failed or promise was cleared), retry —
+                // but cap attempts so a persistent failure doesn't re-load a fresh WASM
+                // module on every seek-bar hover.
                 if (!this.thumbnailBindings) {
+                    if (++this.previewInitAttempts > 3) {
+                        this.previewInitGaveUp = true;
+                        Logger.warn(TAG, "Thumbnail pipeline init failed repeatedly — disabling previews.");
+                        return null;
+                    }
                     Logger.debug(TAG, "Initializing thumbnail pipeline (retry)...");
                     this.previewInitPromise = this.initPreviewPipeline();
                     try {
@@ -2637,6 +2878,15 @@ export class MoviPlayer extends EventEmitter {
             else {
                 throw new Error("No source available for thumbnail pipeline");
             }
+            // Reuse the size the main source already resolved — a dedicated
+            // ThumbnailHttpSource can't probe it on a non-range server (HEAD strips
+            // Content-Length, the 200 GET may be chunked), which used to fail init.
+            if (this.fileSize > 0 &&
+                this.thumbnailSource &&
+                "seedSize" in this.thumbnailSource &&
+                typeof this.thumbnailSource.seedSize === "function") {
+                this.thumbnailSource.seedSize(this.fileSize);
+            }
         }
         const fileSize = await this.thumbnailSource.getSize();
         Logger.debug(TAG, `Thumbnail source created, file size: ${fileSize}`);
@@ -2763,6 +3013,12 @@ export class MoviPlayer extends EventEmitter {
             }
             return result;
         }
+        // Adaptive streams: Shaka already applied the text-track selection (via the
+        // trackManager → streamWrapper wiring) and renders cues itself. There's no
+        // FFmpeg demuxer / subtitle decoder to configure, so stop here.
+        if (this.streamWrapper) {
+            return result;
+        }
         // Configure decoder for new subtitle track
         if (this.demuxer && this.subtitleDecoder) {
             const subtitleTrack = this.trackManager.getActiveSubtitleTrack();
@@ -2829,8 +3085,8 @@ export class MoviPlayer extends EventEmitter {
      * Get current playback time
      */
     getCurrentTime() {
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.getCurrentTime();
+        if (this.streamWrapper) {
+            return this.streamWrapper.getCurrentTime();
         }
         // Subtract seekKeyframeOffset so the timeline reports the user-requested
         // time after a seek instead of where the decoder actually landed (which
@@ -2848,7 +3104,7 @@ export class MoviPlayer extends EventEmitter {
      * re-seeks the demuxer to 0 itself). Pure time-math; touches no media state.
      */
     resetClockToStartForPoster() {
-        if (this.hlsWrapper)
+        if (this.streamWrapper)
             return; // HLS owns its own timeline
         this.clock.seek(this.startTime); // paused → pausedTime = startTime
         this.seekKeyframeOffset = 0; // so getCurrentTime() === 0
@@ -2867,8 +3123,8 @@ export class MoviPlayer extends EventEmitter {
      * Get duration
      */
     getDuration() {
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.getDuration();
+        if (this.streamWrapper) {
+            return this.streamWrapper.getDuration();
         }
         return this.mediaInfo?.duration ?? 0;
     }
@@ -2915,8 +3171,8 @@ export class MoviPlayer extends EventEmitter {
      * Get current state
      */
     getState() {
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.getState();
+        if (this.streamWrapper) {
+            return this.streamWrapper.getState();
         }
         return this.stateManager.getState();
     }
@@ -2971,7 +3227,7 @@ export class MoviPlayer extends EventEmitter {
      * Get HLS video element (DRM mode) for direct DOM insertion
      */
     getHLSVideoElement() {
-        return this.hlsWrapper?.getVideoElement() ?? null;
+        return this.streamWrapper?.getVideoElement() ?? null;
     }
     /**
      * Get chapters from the media (empty array if none)
@@ -2980,12 +3236,16 @@ export class MoviPlayer extends EventEmitter {
         return this.mediaInfo?.chapters ?? [];
     }
     resizeCanvas(width, height) {
-        if (this.hlsWrapper) {
-            this.hlsWrapper.resizeCanvas(width, height);
+        if (this.streamWrapper) {
+            this.streamWrapper.resizeCanvas(width, height);
         }
         if (this.videoRenderer) {
             this.videoRenderer.resize(width, height);
         }
+        // A resize often coincides with a fullscreen / orientation / PiP change —
+        // a good moment to recover a wake lock that dropped or whose first request
+        // failed. Idempotent: no-op when already held / not playing / page hidden.
+        this.ensureWakeLock();
     }
     /**
      * Set HDR enabled state
@@ -3046,8 +3306,8 @@ export class MoviPlayer extends EventEmitter {
         this.videoRenderer?.setManualRotation(deg);
     }
     setFitMode(mode) {
-        if (this.hlsWrapper) {
-            this.hlsWrapper.setFitMode(mode);
+        if (this.streamWrapper) {
+            this.streamWrapper.setFitMode(mode);
         }
         if (this.videoRenderer) {
             this.videoRenderer.setFitMode(mode);
@@ -3062,8 +3322,8 @@ export class MoviPlayer extends EventEmitter {
      * Set playback rate
      */
     setPlaybackRate(rate) {
-        if (this.hlsWrapper) {
-            this.hlsWrapper.setPlaybackRate(rate);
+        if (this.streamWrapper) {
+            this.streamWrapper.setPlaybackRate(rate);
         }
         const savedTime = this.getCurrentTime();
         // Only the corrective seek's purpose (undoing the audio read-ahead pivot)
@@ -3105,7 +3365,11 @@ export class MoviPlayer extends EventEmitter {
         // preservePlaying keeps the play/pause state across it; the seek-session
         // guard keeps rapid rate changes from a superseded completion landing
         // paused. Only when actually playing — see playingNow above.
-        if (playingNow) {
+        // Linear (non-seekable) playback can't do the corrective seek — the
+        // keyframe before savedTime is usually behind the sliding window and the
+        // read would fail (seek timeout → buffering). Skip it; the worst case is a
+        // brief read-ahead pivot on rate change, far better than a stalled seek.
+        if (playingNow && !this.isLinearPlayback()) {
             this.seek(savedTime, {
                 suppressSpinner: true,
                 preservePlaying: true,
@@ -3116,19 +3380,54 @@ export class MoviPlayer extends EventEmitter {
      * Setup native <audio> element for separate audio source.
      * Shared by single audioSource and multi-language audioTracks.
      */
+    /**
+     * Wire the native <audio> element's media events to player state/time. These
+     * only act in native-audio-only mode (split-source data saver) — where there's
+     * no demux loop to emit timeUpdate / detect EOF — and are inert during normal
+     * split-source playback, which the processLoop drives.
+     */
+    wireNativeAudioEvents(el) {
+        el.addEventListener("timeupdate", () => {
+            if (!this.nativeAudioOnlyPlayback())
+                return;
+            this.emit("timeUpdate", this.getCurrentTime());
+        });
+        el.addEventListener("durationchange", () => {
+            if (!this.nativeAudioOnlyPlayback())
+                return;
+            const d = el.duration;
+            if (isFinite(d) && d > 0) {
+                if (this.mediaInfo)
+                    this.mediaInfo.duration = d;
+                this.clock.setDuration(d + this.startTime);
+                this.emit("durationChange", d);
+            }
+        });
+        el.addEventListener("ended", () => {
+            if (!this.nativeAudioOnlyPlayback())
+                return;
+            if (this.stateManager.getState() === "ended")
+                return;
+            const dur = this.getDuration() || 0;
+            this.clock.seek(dur + this.startTime);
+            this.emit("timeUpdate", dur);
+            this.stateManager.setState("ended");
+            this.emit("ended", undefined);
+            this.releaseWakeLock();
+        });
+    }
     setupNativeAudio(url) {
         const wasPlaying = this.nativeAudioEl && !this.nativeAudioEl.paused;
         const currentTime = this.nativeAudioEl?.currentTime ?? 0;
-        const sameSrc = this.nativeAudioEl && this.nativeAudioEl.src === url;
+        // Same-source detection: match the logical URL (the blob path rewrites
+        // .src to a blob: URL) OR the element's raw .src (an adopted element from a
+        // quality switch carries the URL but not our logical-URL field).
+        const sameSrc = !!this.nativeAudioEl &&
+            (this._nativeAudioLogicalUrl === url || this.nativeAudioEl.src === url);
         // Reuse or create element
         if (!this.nativeAudioEl) {
             this.nativeAudioEl = new Audio();
-        }
-        // Skip src reassignment when adopting an already-playing element with the
-        // same URL (quality switch where audio track is shared) — reassigning the
-        // same src triggers a reload and loses the user-activated play() context.
-        if (!sameSrc) {
-            this.nativeAudioEl.src = url;
+            this.wireNativeAudioEvents(this.nativeAudioEl);
         }
         this.nativeAudioEl.preload = "auto";
         this.nativeAudioEl.volume = this.muted ? 0 : this.audioRenderer.getVolume();
@@ -3150,12 +3449,67 @@ export class MoviPlayer extends EventEmitter {
         if (this.videoRenderer) {
             this.videoRenderer.setAudioTimeProvider(() => isAudioReady() ? audioEl.currentTime + self.startTime : -1, isAudioReady);
         }
-        // Restore position and playback state when switching tracks
-        if (currentTime > 0) {
-            audioEl.currentTime = currentTime;
+        // Restore position and resume after the source is in place. Also resume if
+        // the player has since entered "playing" (e.g. autoplay/play() fired while
+        // the headed blob was still fetching, so the earlier audio play() was a
+        // no-op) — this lets the audio join as soon as it's ready.
+        const restorePlayback = () => {
+            if (currentTime > 0)
+                audioEl.currentTime = currentTime;
+            if (wasPlaying || this.stateManager.is("playing")) {
+                audioEl.play().catch(() => { });
+            }
+        };
+        if (sameSrc) {
+            // Adopting an already-playing element with the same URL (quality switch
+            // where the audio track is shared) — reassigning src would reload and
+            // lose the user-activated play() context, so leave it untouched.
+            restorePlayback();
+            return;
         }
-        if (wasPlaying) {
-            audioEl.play().catch(() => { });
+        this._nativeAudioLogicalUrl = url;
+        const headers = this.config.headers;
+        if (headers && Object.keys(headers).length > 0) {
+            // Native <audio> ignores custom request headers, so the .mpd-split / API
+            // audio file would 401/403 without them. Fetch it ourselves with the
+            // headers and play from an in-memory blob: URL. Trade-off: the whole file
+            // is buffered up front (no range streaming) — acceptable for a separate
+            // audio track, and only taken when headers are actually required.
+            this.revokeNativeAudioObjectUrl();
+            fetch(url, { headers })
+                .then((res) => {
+                if (!res.ok)
+                    throw new Error(`HTTP ${res.status}`);
+                return res.blob();
+            })
+                .then((blob) => {
+                // A newer setup (track switch / new source) may have superseded this
+                // fetch while it was in flight — bail so we don't clobber it.
+                if (this.nativeAudioEl !== audioEl || this._nativeAudioLogicalUrl !== url) {
+                    return;
+                }
+                this._nativeAudioObjectUrl = URL.createObjectURL(blob);
+                audioEl.src = this._nativeAudioObjectUrl;
+                restorePlayback();
+            })
+                .catch((e) => {
+                Logger.error(TAG, `Separate audio with custom headers failed to load: ${url}`, e);
+            });
+        }
+        else {
+            this.revokeNativeAudioObjectUrl();
+            audioEl.src = url;
+            restorePlayback();
+        }
+    }
+    /** Release the in-memory blob: URL backing a header-authenticated audio file. */
+    revokeNativeAudioObjectUrl() {
+        if (this._nativeAudioObjectUrl) {
+            try {
+                URL.revokeObjectURL(this._nativeAudioObjectUrl);
+            }
+            catch { }
+            this._nativeAudioObjectUrl = null;
         }
     }
     /**
@@ -3169,6 +3523,13 @@ export class MoviPlayer extends EventEmitter {
     releaseNativeAudio() {
         const el = this.nativeAudioEl;
         if (el) {
+            // Hand the blob: URL (and its logical URL) to the successor via the
+            // element itself, so it reuses the same in-memory audio instead of
+            // re-fetching — and so we DON'T revoke a URL the element still plays.
+            el.__moviLogicalUrl = this._nativeAudioLogicalUrl;
+            el.__moviObjectUrl = this._nativeAudioObjectUrl;
+            this._nativeAudioObjectUrl = null; // ownership moves with the element
+            this._nativeAudioLogicalUrl = null;
             this.nativeAudioEl = null;
         }
         return el;
@@ -3186,6 +3547,14 @@ export class MoviPlayer extends EventEmitter {
             catch { }
         }
         this.nativeAudioEl = el;
+        // Reclaim the blob: URL ownership stashed by releaseNativeAudio, so the
+        // same-source check matches (no re-fetch) and destroy() later revokes it.
+        if (el.__moviObjectUrl !== undefined) {
+            this._nativeAudioObjectUrl = el.__moviObjectUrl ?? null;
+            this._nativeAudioLogicalUrl = el.__moviLogicalUrl ?? null;
+            delete el.__moviObjectUrl;
+            delete el.__moviLogicalUrl;
+        }
     }
     /**
      * Get available audio language tracks (multi-language mode)
@@ -3231,6 +3600,8 @@ export class MoviPlayer extends EventEmitter {
         this.nativeAudioEl.pause();
         this.nativeAudioEl.src = "";
         this.nativeAudioEl = null;
+        this.revokeNativeAudioObjectUrl();
+        this._nativeAudioLogicalUrl = null;
         this._activeAudioLang = "";
         // Re-enable WASM audio
         this.disableAudio = false;
@@ -3259,7 +3630,30 @@ export class MoviPlayer extends EventEmitter {
     hasAudibleSource() {
         return (this.trackManager.getAudioTracks().length > 0 ||
             this.hasNativeAudio() ||
-            this.hlsWrapper !== null);
+            this.streamWrapper !== null);
+    }
+    /** True for a live (dynamic) adaptive stream — drives the LIVE indicator. */
+    isLiveStream() {
+        // Shaka-only extras — undefined on the hls.js/dash.js fallback wrappers.
+        return this.streamWrapper?.isLive?.() ?? false;
+    }
+    /** True when the active adaptive stream is audio-only (no video track). */
+    isStreamAudioOnly() {
+        return this.streamWrapper?.isAudioOnly?.() ?? false;
+    }
+    /** Live-edge time of a live stream (seekable range end). */
+    getLiveEdge() {
+        return this.streamWrapper?.getLiveEdge?.() ?? this.getDuration();
+    }
+    /** Start of a live stream's seekable (DVR) window. */
+    getSeekRangeStart() {
+        return this.streamWrapper?.getSeekRangeStart?.() ?? 0;
+    }
+    /** Jump to the live edge of a live stream. */
+    seekToLive() {
+        const edge = this.getLiveEdge();
+        if (isFinite(edge) && edge > 0)
+            this.streamWrapper?.seek(edge);
     }
     /**
      * Get available external subtitle tracks
@@ -3377,8 +3771,8 @@ export class MoviPlayer extends EventEmitter {
      * Get playback rate
      */
     getPlaybackRate() {
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.getPlaybackRate();
+        if (this.streamWrapper) {
+            return this.streamWrapper.getPlaybackRate();
         }
         return this.clock.getPlaybackRate();
     }
@@ -3561,8 +3955,8 @@ export class MoviPlayer extends EventEmitter {
      * Set volume (0-1)
      */
     setVolume(volume) {
-        if (this.hlsWrapper) {
-            this.hlsWrapper.setVolume(volume);
+        if (this.streamWrapper) {
+            this.streamWrapper.setVolume(volume);
         }
         this.audioRenderer.setVolume(volume);
         if (this.nativeAudioEl) {
@@ -3573,8 +3967,8 @@ export class MoviPlayer extends EventEmitter {
      * Get volume (0-1)
      */
     getVolume() {
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.getVolume();
+        if (this.streamWrapper) {
+            return this.streamWrapper.getVolume();
         }
         return this.audioRenderer.getVolume();
     }
@@ -3585,8 +3979,8 @@ export class MoviPlayer extends EventEmitter {
         if (this.muted === muted)
             return; // No change
         this.muted = muted;
-        if (this.hlsWrapper) {
-            this.hlsWrapper.setMuted(muted);
+        if (this.streamWrapper) {
+            this.streamWrapper.setMuted(muted);
             return;
         }
         if (muted) {
@@ -3601,6 +3995,20 @@ export class MoviPlayer extends EventEmitter {
         }
         if (this.nativeAudioEl) {
             this.nativeAudioEl.muted = muted;
+            // Unmuting resolves a native-audio autoplay block. The <audio> couldn't
+            // start without a gesture, so the video has been rolling on the wall clock
+            // with the audio paused — THIS unmute is the gesture. Sync the audio to
+            // the current playhead and start it; it then re-assumes clock-master duty.
+            if (!muted && this._nativeAudioAutoplayBlocked) {
+                this._nativeAudioAutoplayBlocked = false;
+                if (this.nativeAudioEl.paused && this.stateManager.getState() === "playing") {
+                    try {
+                        this.nativeAudioEl.currentTime = Math.max(0, this.clock.getTime() - this.startTime);
+                    }
+                    catch { }
+                    this.nativeAudioEl.play().catch(() => { });
+                }
+            }
         }
     }
     /**
@@ -3628,8 +4036,8 @@ export class MoviPlayer extends EventEmitter {
      */
     getStats() {
         // HLS mode: delegate to HLS wrapper
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.getStats();
+        if (this.streamWrapper) {
+            return this.streamWrapper.getStats();
         }
         const mediaInfo = this.mediaInfo;
         const videoTrack = this.trackManager.getActiveVideoTrack();
@@ -3755,8 +4163,8 @@ export class MoviPlayer extends EventEmitter {
      */
     getNetworkSpeed() {
         // HLS mode: delegate to HLS wrapper
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.getNetworkSpeed();
+        if (this.streamWrapper) {
+            return this.streamWrapper.getNetworkSpeed();
         }
         // EncryptedHttpSource extends HttpSource, so the HttpSource branch
         // covers encrypted playback too.
@@ -3772,10 +4180,20 @@ export class MoviPlayer extends EventEmitter {
      * Check if source is a local file
      */
     isFileSource() {
-        if (this.hlsWrapper)
+        if (this.streamWrapper)
             return false;
         return this.source instanceof FileSource;
     }
+    /**
+     * True when the active source has fallen back to linear (forward-only,
+     * non-seekable) playback — server lacks HTTP Range support and the file is
+     * too big to cache whole. Used by the UI as a backstop alongside the
+     * "linearmode" event (in case the event fired before listeners attached).
+     */
+    isLinearPlayback() {
+        const src = this.source;
+        return typeof src?.isLinearMode === "function" ? src.isLinearMode() : false;
+    }
     /**
      * True when audio is blocked by the browser's autoplay policy — the
      * AudioContext is stuck suspended despite an unmuted play() because no
@@ -3784,10 +4202,73 @@ export class MoviPlayer extends EventEmitter {
      * muted playback + a "Tap to unmute" pill.
      */
     isAudioBlockedSuspended() {
-        if (this.disableAudio || this.hlsWrapper)
+        if (this.streamWrapper)
+            return false;
+        // Native <audio> autoplay blocked → muted-and-rolling: report blocked so
+        // the element shows the unmute pill (disableAudio is true in this path, so
+        // it must be checked before the disableAudio short-circuit below).
+        if (this._nativeAudioAutoplayBlocked)
+            return true;
+        if (this.disableAudio)
             return false;
         return this.audioRenderer.isBlockedSuspended();
     }
+    /** True when audio-only (data-saver) mode is active. */
+    isAudioOnly() {
+        return this._audioOnly;
+    }
+    /**
+     * Toggle audio-only (data-saver) mode at runtime. On the demuxer path the
+     * processLoop stops decoding video (CPU saving) — re-enabling re-seeks to
+     * recover a keyframe and resume video in sync. Adaptive streams drop/restore
+     * video renditions via a reload (config.audioOnly), so this only flips the
+     * flag for them; the caller (MoviElement) owns that reload.
+     */
+    setAudioOnly(enabled) {
+        if (this._audioOnly === enabled)
+            return;
+        this._audioOnly = enabled;
+        if (this.streamWrapper) {
+            // Adaptive streams: the wrapper picks an audio-only / smallest-video
+            // variant live (no reload, so the stream — and its LIVE state — survives).
+            this.streamWrapper.setAudioOnly?.(enabled);
+            return;
+        }
+        const splitSource = !!this.nativeAudioEl; // separate <audio> drives playback
+        if (enabled) {
+            // Freeze the video surface cleanly — drop queued + on-screen frames so the
+            // UI can swap to the album-art / strip view without a stale last frame.
+            if (this.videoRenderer)
+                this.videoRenderer.clearQueue();
+            if (splitSource) {
+                // Split source: stop the demux loop entirely so the video body stops
+                // downloading + decoding. The native <audio> keeps playing on its own.
+                // (Doing this live — never via a reload — avoids tearing down the WASM
+                // context while a read is in flight, which crashes with an OOB.)
+                if (this.animationFrameId !== null) {
+                    cancelAnimationFrame(this.animationFrameId);
+                    this.animationFrameId = null;
+                }
+                this.stopPauseBuffering();
+            }
+            // Muxed source: keep the demux loop running (it still decodes the in-file
+            // audio); the processLoop's _audioOnly check skips only the video decode.
+        }
+        else {
+            // Re-enabling video. Seek to the current playhead to recover a keyframe and
+            // resync; for a split source the demux loop was stopped, so restart it.
+            const t = this.getCurrentTime();
+            this.seek(t)
+                .then(() => {
+                if (splitSource &&
+                    this.animationFrameId === null &&
+                    this.stateManager.getState() === "playing") {
+                    this.processLoop();
+                }
+            })
+                .catch((e) => Logger.warn(TAG, "Audio-only → video resync seek failed", e));
+        }
+    }
     /**
      * True when the active source is not a FileSource (gate inactive), or when
      * the FileSource's initial preload pass has settled.
@@ -3807,12 +4288,19 @@ export class MoviPlayer extends EventEmitter {
     /**
      * Request WakeLock to prevent screen sleep
      */
-    async requestWakeLock() {
+    async requestWakeLock(retry = 1) {
         // Check if WakeLock API is available
         if (!("wakeLock" in navigator)) {
             Logger.debug(TAG, "WakeLock API not available");
             return;
         }
+        // The Screen Wake Lock API rejects (NotAllowedError) unless the page is
+        // visible — don't even attempt while hidden. It's the wrong moment, not a
+        // fault; handleVisibilityChange re-requests once the tab is shown.
+        if (typeof document !== "undefined" && document.visibilityState !== "visible") {
+            Logger.debug(TAG, "WakeLock skipped — page not visible");
+            return;
+        }
         try {
             // Release existing wakeLock if any
             if (this.wakeLock) {
@@ -3829,10 +4317,42 @@ export class MoviPlayer extends EventEmitter {
             });
         }
         catch (error) {
-            Logger.warn(TAG, "Failed to acquire WakeLock", error);
             this.wakeLock = null;
+            Logger.warn(TAG, "Failed to acquire WakeLock", error);
+            // Some devices reject the very FIRST request transiently even while
+            // visible (a race as the page becomes fully interactive), then never
+            // re-acquire for the rest of the session. Retry once shortly — but only
+            // if we still want the lock (active playback, visible, none held).
+            if (retry > 0) {
+                setTimeout(() => {
+                    const st = this.stateManager.getState();
+                    if (!this.wakeLock &&
+                        (st === "playing" || st === "buffering") &&
+                        typeof document !== "undefined" &&
+                        document.visibilityState === "visible") {
+                        this.requestWakeLock(retry - 1);
+                    }
+                }, 600);
+            }
         }
     }
+    /**
+     * Re-acquire the screen wake lock if we should be holding one but aren't.
+     * Called on the moments where the lock can quietly drop, or where a failed
+     * first attempt gets a fresh chance: tab visibility changes and player
+     * resizes (fullscreen / orientation / PiP transitions). Idempotent — no-op
+     * when a lock is already held, playback isn't active, or the page is hidden.
+     */
+    ensureWakeLock() {
+        if (this.wakeLock)
+            return; // already held
+        const st = this.stateManager.getState();
+        if (st !== "playing" && st !== "buffering")
+            return; // not actively playing
+        if (typeof document !== "undefined" && document.visibilityState !== "visible")
+            return;
+        this.requestWakeLock();
+    }
     /**
      * Handle network recovery — re-seek to current position to restart cleanly
      */
@@ -3896,6 +4416,9 @@ export class MoviPlayer extends EventEmitter {
             // Tab visible again — stop background timer, RAF takes over
             this.isBackgrounded = false;
             this.stopBackgroundTimer();
+            // The system drops the wake lock whenever the tab hides; now that we're
+            // visible again, re-acquire it (idempotent, gated on active playback).
+            this.ensureWakeLock();
             if (isPlaying) {
                 // Resume AudioContext if needed. On mobile after long background the
                 // browser may keep it suspended (autoplay policy — prior gesture has
@@ -3997,11 +4520,9 @@ export class MoviPlayer extends EventEmitter {
                     // PiP was active — just restart processLoop, video was rendering in PiP
                     this.processLoop();
                 }
-                setTimeout(() => {
-                    if (this.stateManager.getState() === "playing") {
-                        this.requestWakeLock();
-                    }
-                }, 500);
+                // Re-acquire once playback has settled back in — idempotent, so it's a
+                // no-op if ensureWakeLock above already got it.
+                setTimeout(() => this.ensureWakeLock(), 500);
             }
         }
     };
@@ -4077,6 +4598,10 @@ export class MoviPlayer extends EventEmitter {
             return;
         if (!this.demuxer || this.eofReached)
             return;
+        // Native-audio-only: never read the demuxer — that would download the very
+        // video body the data-saver mode exists to skip.
+        if (this.nativeAudioOnlyPlayback())
+            return;
         // Only for HTTP sources — local files are already fully available
         if (this.source instanceof FileSource)
             return;
@@ -4201,8 +4726,8 @@ export class MoviPlayer extends EventEmitter {
      * Returns the furthest time position that has been buffered
      */
     getBufferedTime() {
-        if (this.hlsWrapper) {
-            return this.hlsWrapper.getBufferEndTime();
+        if (this.streamWrapper) {
+            return this.streamWrapper.getBufferEndTime();
         }
         if (!this.mediaInfo || !this.source) {
             return 0;
@@ -4317,6 +4842,25 @@ export class MoviPlayer extends EventEmitter {
         }
         return 0;
     }
+    /**
+     * Lowest time a backward seek can SAFELY land in linear (non-range) playback.
+     * The window starts at getBufferStartTime, but a seek's keyframe sits at a
+     * lower byte than the linear time→byte estimate (GOP span + VBR), so seeking
+     * right at the window edge usually reads just below it and fails. Pad the
+     * start by a byte safety margin so the keyframe stays inside the RAM window.
+     * Returns 0 for seekable (range-capable) or non-HTTP sources.
+     */
+    getSeekableStartTime() {
+        if (!this.mediaInfo ||
+            !(this.source instanceof HttpSource) ||
+            this.fileSize <= 0 ||
+            !this.source.isLinearMode()) {
+            return 0;
+        }
+        const MARGIN_BYTES = 96 * 1024 * 1024; // covers a keyframe-before-target gap
+        const safeBytes = Math.min(this.fileSize, this.source.getBufferStart() + MARGIN_BYTES);
+        return Math.min(this.mediaInfo.duration, (safeBytes / this.fileSize) * this.mediaInfo.duration);
+    }
     /**
      * Get buffer end time in seconds (for HttpSource)
      * Same as getBufferedTime but more explicit
@@ -4445,10 +4989,10 @@ export class MoviPlayer extends EventEmitter {
         }
         this.stopBackgroundTimer();
         this.stopPauseBuffering();
-        // Destroy HLS wrapper
-        if (this.hlsWrapper) {
-            this.hlsWrapper.destroy();
-            this.hlsWrapper = null;
+        // Destroy the adaptive-streaming wrapper (HLS or DASH, via Shaka)
+        if (this.streamWrapper) {
+            this.streamWrapper.destroy();
+            this.streamWrapper = null;
         }
         this.pendingPrebufferPackets = [];
         // Close resources
@@ -4469,6 +5013,8 @@ export class MoviPlayer extends EventEmitter {
             this.nativeAudioEl.src = "";
             this.nativeAudioEl = null;
         }
+        this.revokeNativeAudioObjectUrl();
+        this._nativeAudioLogicalUrl = null;
         // Cleanup external subtitles
         this.stopExternalSubtitles();
         this._externalSubCues = [];