@nomercy-entertainment/nomercy-video-player 2.0.2 → 2.0.4

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [2.0.3] — 2026-07-31
+
+### Fixed
+
+- `desktop-ui`: the full-width rows ran past their parent by exactly their own padding. `top-row`, `bottom-row`, `language-button` and `playlist-menu-button` each set `width: 100%` alongside horizontal padding without `border-box`, so consumers were patching the overflow themselves.
+
+### Changed
+
+- Built against `@nomercy-entertainment/nomercy-player-core@2.0.3`, which carries the fix for a start item picked between `setup()` and `ready()`. A `?season=&episode=` style deep link now opens on the item it names.
+
 ## [2.0.1] — 2026-07-18
 
 First published stable of the v2 line (2.0.0 was withdrawn before release), published under the `latest` dist-tag — a plain `npm install @nomercy-entertainment/nomercy-video-player` now resolves `2.0.1` instead of the v1 `1.2.7`. Built against the stable `@nomercy-entertainment/nomercy-player-core@^2.0.1`. The entries below shipped since `2.0.0-rc.35`; everything earlier is captured in the release-candidate history.

package/dist/adapters/video-backend/IVideoBackend.d.ts

@@ -1,4 +1,4 @@
-import type { AudioTrack, BackendLoaderState, BackendState, MinimalBackendEventPayload, QualityLevel, SubtitleCueChange, SubtitleTrack } from '@nomercy-entertainment/nomercy-player-core';
+import type { AudioTrack, AuthHeaderProvider, BackendLoaderState, BackendState, HdrOnSdrFallback, MinimalBackendEventPayload, QualityLevel, SubtitleCueChange, SubtitleTrack } from '@nomercy-entertainment/nomercy-player-core';
 import type { HtmlPreloadMode } from '../../types.js';
 /**
  * Per-event payload map. Each backend event has a fixed payload shape so
@@ -135,13 +135,36 @@ export interface IVideoBackend {
      * manifests/segments). Optional — backends without their own network
      * stack omit it.
      */
-    setAuthHeaderProvider?(provider: () => string | undefined | Promise<string | undefined>): void;
+    setAuthHeaderProvider?(provider: AuthHeaderProvider): void;
+    /**
+     * Consumer policy for an all-HDR item on a display that can't show HDR and
+     * a backend that can't tone-map it. Optional — backends that never face the
+     * question (no HDR-aware ABR) omit it. `NMVideoPlayer` pushes `options.hdrOnSdr`
+     * here once, at backend construction; unset means the backend's own default.
+     */
+    setHdrOnSdrFallback?(fallback: HdrOnSdrFallback): void;
     play(): Promise<void>;
     pause(): void;
     stop(): void;
     currentTime(): number;
     currentTime(seconds: number): void;
     duration(): number;
+    /**
+     * The absolute timeline position, in seconds, that buffered data reaches.
+     * Not a duration ahead of the playhead, and not a fraction: a scrubber
+     * draws its buffered bar as `buffered() / duration()`, the same frame of
+     * reference `currentTime()` and `duration()` use.
+     *
+     * Contiguous from the playhead. The frontier is the end of the range the
+     * playhead is inside, so a range on the far side of a hole does not count
+     * towards it — a seek back an hour leaves `[0, 90]` and `[3500, 3600]`
+     * with the playhead at 5, and a bar drawn to 3600 promises an hour of
+     * buffer over a stretch that holds none.
+     *
+     * When nothing is buffered ahead — the playhead sits in a hole, or before
+     * the first range — the answer is the playhead's own position, which draws
+     * no bar ahead of it. `0` when no data is buffered at all.
+     */
     buffered(): number;
     bufferedRanges(): TimeRanges;
     seekable(): TimeRanges;

package/dist/adapters/video-backend/html5.d.ts

@@ -1,4 +1,4 @@
-import type { AudioTrack, QualityLevel, SubtitleTrack } from '@nomercy-entertainment/nomercy-player-core';
+import type { AudioTrack, HdrOnSdrFallback, QualityLevel, SubtitleTrack } from '@nomercy-entertainment/nomercy-player-core';
 import type { HtmlPreloadMode } from '../../types.js';
 import type { BackendEventPayload, BackendState, IVideoBackend } from './IVideoBackend.js';
 import { MediaElementBackend } from '@nomercy-entertainment/nomercy-player-core';
@@ -86,6 +86,25 @@ export declare class Html5VideoBackend extends MediaElementBackend<HTMLVideoElem
      *  `removeEventListener` with the same reference on dispose.
      */
     private _hdrMqlListener;
+    /**
+     * Consumer policy for an all-HDR item on an SDR display, pushed in by
+     * `NMVideoPlayer` via `setHdrOnSdrFallback`. `undefined` until then —
+     * `hdrDecision`'s own default (`'play'`) applies at read time.
+     */
+    private _hdrOnSdrFallback;
+    /**
+     * Observer on the media element, so the ceiling follows a window drag, a
+     * fullscreen toggle and an orientation change. The facade's own observer
+     * feeds the `videoRect` event on `NMVideoPlayer` and the backend holds no
+     * reference to the facade, so the size signal is re-derived here.
+     */
+    private _paneObserver;
+    /**
+     * Pending coalesced re-apply. A drag fires the observer on every frame and
+     * every `autoLevelCapping` write is a decision ABR has to react to, so the
+     * burst collapses into one apply.
+     */
+    private _paneReapplyTimer;
     constructor(container: HTMLElement);
     /**
      * `startTime` is consumed natively (declared via `canStartAt`): the hls.js
@@ -224,11 +243,33 @@ export declare class Html5VideoBackend extends MediaElementBackend<HTMLVideoElem
      * overlay plugins can update button visibility without polling.
      *
      * Also builds the per-level HDR classification table and immediately
-     * applies the dynamic-range ABR constraint for the current display.
+     * applies the ABR constraints for the current display and pane size.
      */
     private _emitHlsTrackLists;
-    /** Wire the `matchMedia('(dynamic-range: high)')` change listener once. */
+    /**
+     * Consumer policy for an all-HDR item on an SDR display with no converter.
+     * Pushed once by `NMVideoPlayer` right after construction — see `IVideoBackend`.
+     */
+    setHdrOnSdrFallback(fallback: HdrOnSdrFallback): void;
+    /**
+     * Wire a combined-query matchMedia listener once. The comma joins the two
+     * queries as an OR at the CSS level, so one listener catches a change in
+     * either signal; the boolean answer itself always comes from
+     * `detectDisplayHdr`, which asks them in priority order (video plane
+     * before page) rather than trusting whichever one the event fired for.
+     */
     private _wireHdrMatchMedia;
+    /**
+     * Watch the media element's box so the pane ceiling follows the layout.
+     *
+     * The element rather than the container: `object-fit` letterboxing means the
+     * container can be wider than the picture, and the picture is what a
+     * rendition has to cover.
+     */
+    private _wirePaneResizeObserver;
+    private _schedulePaneReapply;
+    /** Disconnect the pane observer and drop a pending re-apply. Called from `dispose()`. */
+    private _teardownPaneResizeObserver;
     /** Remove the matchMedia listener. Called from `dispose()`. */
     private _teardownHdrMatchMedia;
     /**
@@ -237,25 +278,42 @@ export declare class Html5VideoBackend extends MediaElementBackend<HTMLVideoElem
      */
     private _classifyHdrLevels;
     /**
-     * Constrain HLS.js ABR to the display's dynamic-range capability.
+     * Constrain HLS.js ABR to what this display and this pane can actually show,
+     * per `hdrDecision` and `sizeAbrCeiling` — the oracles both native ports
+     * mirror. The only writer of `autoLevelCapping`.
+     *
+     * The pane ceiling applies on every branch, including the ones with no
+     * dynamic-range cap to make: an SDR item in a 740px player is the ordinary
+     * case, and it is the one that was pulling a 4K rendition.
+     *
+     * `as-is` (HDR display, or an ordinary SDR item with no HDR rungs to cap):
+     *   - `autoLevelCapping` falls back to the pane ceiling, or `-1` when the
+     *     pane is unmeasured or already as large as the ladder's best rung. If
+     *     the current level is SDR and an HDR peer exists at the same
+     *     resolution, prefer it via `nextLevel` (soft switch — the next fragment
+     *     boundary picks it up, no stutter). The peer shares the current level's
+     *     resolution, so it cannot violate the pane ceiling. A no-op on the
+     *     SDR-only case: there is no HDR peer to find.
+     *
+     * `cap-to` (SDR display, an SDR rung exists):
+     *   - Caps `autoLevelCapping` to the more restrictive of the dynamic-range
+     *     rung and the pane rung, by raw manifest index. For interleaved
+     *     manifests (HDR index < SDR index at the same resolution) the cap alone
+     *     is insufficient — `nextLevel` also forces off any currently-playing
+     *     HDR variant to its SDR peer.
+     *
+     * `tone-map` — never returned here; see `backendCanToneMap` below.
+     *
+     * `play-unconverted` — no SDR rung, no converter, consumer opted in: the
+     *   dynamic range goes unconstrained on purpose, the pane ceiling still
+     *   holds, no error.
      *
-     * SDR display (`displayHdr = false`):
-     *   - Sets `hls.autoLevelCapping` to the highest SDR level index so the
-     *     ABR algorithm never auto-selects above it. For interleaved manifests
-     *     where some HDR level indices sit below some SDR level indices,
-     *     `autoLevelCapping` alone is insufficient — we also force a `nextLevel`
-     *     switch away from any currently-playing HDR variant to its nearest SDR
-     *     peer at the same (or next-lower) resolution.
-     *   - Emits a fresh `levels` event so overlay plugins can hide HDR rows.
+     * `refuse` — no SDR rung, no converter, consumer opted out: escalated
+     *   through the same fatal-error channel HLS stream errors use.
      *
-     * HDR display (`displayHdr = true`):
-     *   - Lifts `autoLevelCapping` to `-1` (uncapped). ABR is free to select
-     *     HDR variants. If the current level is SDR and an HDR peer exists at
-     *     the same resolution, prefer it by setting `nextLevel` (soft switch —
-     *     the next fragment boundary picks it up; no stutter).
-     *   - Emits a fresh `levels` event so overlay plugins can reveal HDR rows.
+     * Always re-emits `levels` so overlay plugins can update their menus.
      */
-    private _applyHdrConstraint;
+    private _applyAbrConstraints;
     /** Called by the matchMedia listener when the display's HDR capability changes. */
     private _onDisplayHdrChange;
     /**

package/dist/adapters/video-backend/html5.js

@@ -5,7 +5,7 @@
 //
 //  SPDX-License-Identifier: Apache-2.0
 // -----------------------------------------------------------------------------
-import { appendAuthTokenParam, createAuthorizationXhrSetup, destroyHlsInstance, isHls, MediaElementBackend, MediaFormatError, resetMediaElement, supportsNativeHls, } from '@nomercy-entertainment/nomercy-player-core';
+import { abrCeiling, appendAuthTokenParam, createAuthorizationXhrSetup, destroyHlsInstance, detectDisplayHdr, hdrDecision, isHls, MediaElementBackend, MediaFormatError, mediaFormatError, panePixels, resetMediaElement, sizeAbrCeiling, supportsNativeHls, } from '@nomercy-entertainment/nomercy-player-core';
 const CODEC_LABELS = [
     [/avc1|h264/i, 'H.264'],
     [/hvc1|hev1|h265/i, 'H.265 (HEVC)'],
@@ -117,6 +117,25 @@ export class Html5VideoBackend extends MediaElementBackend {
      *  `removeEventListener` with the same reference on dispose.
      */
     _hdrMqlListener;
+    /**
+     * Consumer policy for an all-HDR item on an SDR display, pushed in by
+     * `NMVideoPlayer` via `setHdrOnSdrFallback`. `undefined` until then —
+     * `hdrDecision`'s own default (`'play'`) applies at read time.
+     */
+    _hdrOnSdrFallback;
+    /**
+     * Observer on the media element, so the ceiling follows a window drag, a
+     * fullscreen toggle and an orientation change. The facade's own observer
+     * feeds the `videoRect` event on `NMVideoPlayer` and the backend holds no
+     * reference to the facade, so the size signal is re-derived here.
+     */
+    _paneObserver;
+    /**
+     * Pending coalesced re-apply. A drag fires the observer on every frame and
+     * every `autoLevelCapping` write is a decision ABR has to react to, so the
+     * burst collapses into one apply.
+     */
+    _paneReapplyTimer;
     constructor(container) {
         const existing = container.querySelector('video');
         let element;
@@ -133,6 +152,7 @@ export class Html5VideoBackend extends MediaElementBackend {
         super(element, ownsElement, 'html5');
         this.wireElementEvents();
         this._wireHdrMatchMedia();
+        this._wirePaneResizeObserver();
     }
     // ── Lifecycle ──
     /**
@@ -199,7 +219,7 @@ export class Html5VideoBackend extends MediaElementBackend {
         // what produces the ~8 s stall on auto-advance.
         resetMediaElement(this.element);
         performance.mark('nm:backend:load:start');
-        const headerValue = await this._authHeaderProvider?.();
+        const headerValue = this._authHeaderProvider?.(url);
         if (hlsUrl && !nativeHls) {
             const { default: Hls } = await import('hls.js');
             if (!Hls?.isSupported?.()) {
@@ -219,7 +239,7 @@ export class Html5VideoBackend extends MediaElementBackend {
                 enableCEA708Captions: true,
                 startPosition: typeof opts?.startTime === 'number' && opts.startTime > 0 ? opts.startTime : -1,
                 startFragPrefetch: true,
-                xhrSetup: createAuthorizationXhrSetup(headerValue),
+                xhrSetup: createAuthorizationXhrSetup(this._authHeaderProvider),
             });
             this.hls = hlsInstance;
             this.hlsInstance = hlsInstance;
@@ -280,6 +300,7 @@ export class Html5VideoBackend extends MediaElementBackend {
             this._retryTimer = undefined;
         }
         this._teardownHdrMatchMedia();
+        this._teardownPaneResizeObserver();
         this._teardownAudioGraph();
         this.unload();
         this.detachDomBridges(this.element);
@@ -912,13 +933,13 @@ export class Html5VideoBackend extends MediaElementBackend {
      * overlay plugins can update button visibility without polling.
      *
      * Also builds the per-level HDR classification table and immediately
-     * applies the dynamic-range ABR constraint for the current display.
+     * applies the ABR constraints for the current display and pane size.
      */
     _emitHlsTrackLists() {
         if (!this.hls)
             return;
         this._classifyHdrLevels();
-        this._applyHdrConstraint(this._displayHdr);
+        this._applyAbrConstraints(this._displayHdr);
         void this._probeCodecCapabilities().then(() => {
             const levels = this.qualityLevels();
             this.emit('levels', { levels });
@@ -927,20 +948,66 @@ export class Html5VideoBackend extends MediaElementBackend {
         if (tracks.length > 0)
             this.emit('audioTracks', { tracks });
     }
-    // ── HDR-aware ABR helpers ──
-    /** Wire the `matchMedia('(dynamic-range: high)')` change listener once. */
+    // ── Display- and pane-aware ABR helpers ──
+    /**
+     * Consumer policy for an all-HDR item on an SDR display with no converter.
+     * Pushed once by `NMVideoPlayer` right after construction — see `IVideoBackend`.
+     */
+    setHdrOnSdrFallback(fallback) {
+        this._hdrOnSdrFallback = fallback;
+    }
+    /**
+     * Wire a combined-query matchMedia listener once. The comma joins the two
+     * queries as an OR at the CSS level, so one listener catches a change in
+     * either signal; the boolean answer itself always comes from
+     * `detectDisplayHdr`, which asks them in priority order (video plane
+     * before page) rather than trusting whichever one the event fired for.
+     */
     _wireHdrMatchMedia() {
         if (typeof window === 'undefined' || typeof window.matchMedia !== 'function')
             return;
-        const mql = window.matchMedia('(dynamic-range: high)');
-        this._displayHdr = mql.matches;
+        const mql = window.matchMedia('(video-dynamic-range: high), (dynamic-range: high)');
+        this._displayHdr = detectDisplayHdr();
         this._hdrMql = mql;
-        const listener = (event) => {
-            this._onDisplayHdrChange(event.matches);
+        const listener = () => {
+            this._onDisplayHdrChange(detectDisplayHdr());
         };
         this._hdrMqlListener = listener;
         mql.addEventListener('change', listener);
     }
+    /**
+     * Watch the media element's box so the pane ceiling follows the layout.
+     *
+     * The element rather than the container: `object-fit` letterboxing means the
+     * container can be wider than the picture, and the picture is what a
+     * rendition has to cover.
+     */
+    _wirePaneResizeObserver() {
+        if (typeof ResizeObserver === 'undefined')
+            return;
+        const observer = new ResizeObserver(() => {
+            this._schedulePaneReapply();
+        });
+        observer.observe(this.element);
+        this._paneObserver = observer;
+    }
+    _schedulePaneReapply() {
+        if (this._paneReapplyTimer !== undefined)
+            return;
+        this._paneReapplyTimer = setTimeout(() => {
+            this._paneReapplyTimer = undefined;
+            this._applyAbrConstraints(this._displayHdr);
+        }, 0);
+    }
+    /** Disconnect the pane observer and drop a pending re-apply. Called from `dispose()`. */
+    _teardownPaneResizeObserver() {
+        if (this._paneReapplyTimer !== undefined) {
+            clearTimeout(this._paneReapplyTimer);
+            this._paneReapplyTimer = undefined;
+        }
+        this._paneObserver?.disconnect();
+        this._paneObserver = undefined;
+    }
     /** Remove the matchMedia listener. Called from `dispose()`. */
     _teardownHdrMatchMedia() {
         if (this._hdrMql && this._hdrMqlListener) {
@@ -964,57 +1031,90 @@ export class Html5VideoBackend extends MediaElementBackend {
         });
     }
     /**
-     * Constrain HLS.js ABR to the display's dynamic-range capability.
+     * Constrain HLS.js ABR to what this display and this pane can actually show,
+     * per `hdrDecision` and `sizeAbrCeiling` — the oracles both native ports
+     * mirror. The only writer of `autoLevelCapping`.
+     *
+     * The pane ceiling applies on every branch, including the ones with no
+     * dynamic-range cap to make: an SDR item in a 740px player is the ordinary
+     * case, and it is the one that was pulling a 4K rendition.
+     *
+     * `as-is` (HDR display, or an ordinary SDR item with no HDR rungs to cap):
+     *   - `autoLevelCapping` falls back to the pane ceiling, or `-1` when the
+     *     pane is unmeasured or already as large as the ladder's best rung. If
+     *     the current level is SDR and an HDR peer exists at the same
+     *     resolution, prefer it via `nextLevel` (soft switch — the next fragment
+     *     boundary picks it up, no stutter). The peer shares the current level's
+     *     resolution, so it cannot violate the pane ceiling. A no-op on the
+     *     SDR-only case: there is no HDR peer to find.
+     *
+     * `cap-to` (SDR display, an SDR rung exists):
+     *   - Caps `autoLevelCapping` to the more restrictive of the dynamic-range
+     *     rung and the pane rung, by raw manifest index. For interleaved
+     *     manifests (HDR index < SDR index at the same resolution) the cap alone
+     *     is insufficient — `nextLevel` also forces off any currently-playing
+     *     HDR variant to its SDR peer.
      *
-     * SDR display (`displayHdr = false`):
-     *   - Sets `hls.autoLevelCapping` to the highest SDR level index so the
-     *     ABR algorithm never auto-selects above it. For interleaved manifests
-     *     where some HDR level indices sit below some SDR level indices,
-     *     `autoLevelCapping` alone is insufficient — we also force a `nextLevel`
-     *     switch away from any currently-playing HDR variant to its nearest SDR
-     *     peer at the same (or next-lower) resolution.
-     *   - Emits a fresh `levels` event so overlay plugins can hide HDR rows.
+     * `tone-map` — never returned here; see `backendCanToneMap` below.
      *
-     * HDR display (`displayHdr = true`):
-     *   - Lifts `autoLevelCapping` to `-1` (uncapped). ABR is free to select
-     *     HDR variants. If the current level is SDR and an HDR peer exists at
-     *     the same resolution, prefer it by setting `nextLevel` (soft switch —
-     *     the next fragment boundary picks it up; no stutter).
-     *   - Emits a fresh `levels` event so overlay plugins can reveal HDR rows.
+     * `play-unconverted` — no SDR rung, no converter, consumer opted in: the
+     *   dynamic range goes unconstrained on purpose, the pane ceiling still
+     *   holds, no error.
+     *
+     * `refuse` — no SDR rung, no converter, consumer opted out: escalated
+     *   through the same fatal-error channel HLS stream errors use.
+     *
+     * Always re-emits `levels` so overlay plugins can update their menus.
      */
-    _applyHdrConstraint(displayHdr) {
+    _applyAbrConstraints(displayHdr) {
         this._displayHdr = displayHdr;
         if (!this.hls || this._levelIsHdr.length === 0)
             return;
-        if (displayHdr) {
-            // Lift the cap — ABR can now pick HDR variants.
-            this.hls.autoLevelCapping = -1;
-            // Upgrade the playing level to an HDR peer at the same resolution
-            // if we were previously constrained to SDR.
-            const playingIdx = this.currentLevel();
-            if (playingIdx >= 0 && !this._levelIsHdr[playingIdx]) {
-                const currentHeight = this.hls.levels[playingIdx]?.height;
-                const hdrPeerIdx = this.hls.levels.findIndex((level, idx) => this._levelIsHdr[idx] && level.height === currentHeight);
-                if (hdrPeerIdx >= 0)
-                    this.hls.nextLevel = hdrPeerIdx;
+        const levels = this.qualityLevels();
+        const pane = panePixels(this.element);
+        const sizeCeiling = sizeAbrCeiling(levels, pane.widthPx, pane.heightPx);
+        const sizeCapIndex = sizeCeiling === null ? -1 : sizeCeiling.index;
+        // Neither hls.js nor any shipping <video> implementation performs an
+        // HDR→SDR tone-map during decode — a platform fact, not unfinished work.
+        const backendCanToneMap = false;
+        const decision = hdrDecision(levels, displayHdr, backendCanToneMap, this._hdrOnSdrFallback ?? 'play');
+        switch (decision.kind) {
+            case 'as-is': {
+                this.hls.autoLevelCapping = sizeCapIndex;
+                const playingIdx = this.currentLevel();
+                if (playingIdx >= 0 && !this._levelIsHdr[playingIdx]) {
+                    const currentHeight = this.hls.levels[playingIdx]?.height;
+                    const hdrPeerIdx = this.hls.levels.findIndex((level, idx) => this._levelIsHdr[idx] && level.height === currentHeight);
+                    if (hdrPeerIdx >= 0)
+                        this.hls.nextLevel = hdrPeerIdx;
+                }
+                break;
             }
-        }
-        else {
-            // Find the highest-indexed SDR level — cap ABR there.
-            let maxSdrIdx = -1;
-            for (let idx = 0; idx < this._levelIsHdr.length; idx++) {
-                if (!this._levelIsHdr[idx])
-                    maxSdrIdx = idx;
+            case 'cap-to': {
+                const ceiling = abrCeiling(decision.level, sizeCeiling) ?? decision.level;
+                this.hls.autoLevelCapping = ceiling.index;
+                const playingIdx = this.currentLevel();
+                if (playingIdx >= 0 && this._levelIsHdr[playingIdx]) {
+                    const currentHeight = this.hls.levels[playingIdx]?.height;
+                    const sdrPeerIdx = this.hls.levels.findIndex((level, idx) => !this._levelIsHdr[idx] && level.height === currentHeight);
+                    this.hls.nextLevel = sdrPeerIdx >= 0 ? sdrPeerIdx : ceiling.index;
+                }
+                break;
+            }
+            case 'tone-map': {
+                // Unreachable while `backendCanToneMap` is false above — handled
+                // explicitly so a backend that DOES gain a converter can't fall
+                // through this switch unnoticed.
+                break;
+            }
+            case 'play-unconverted': {
+                this.hls.autoLevelCapping = sizeCapIndex;
+                break;
             }
-            this.hls.autoLevelCapping = maxSdrIdx;
-            // If currently playing an HDR level, force-switch to the best SDR peer.
-            const playingIdx = this.currentLevel();
-            if (playingIdx >= 0 && this._levelIsHdr[playingIdx]) {
-                const currentHeight = this.hls.levels[playingIdx]?.height;
-                const sdrPeerIdx = this.hls.levels.findIndex((level, idx) => !this._levelIsHdr[idx] && level.height === currentHeight);
-                const targetIdx = sdrPeerIdx >= 0 ? sdrPeerIdx : maxSdrIdx;
-                if (targetIdx >= 0)
-                    this.hls.nextLevel = targetIdx;
+            case 'refuse': {
+                const err = mediaFormatError('video:media/hdr-unplayable', 'Every rendition in this manifest is HDR and the active display cannot render HDR.');
+                this._escalateHlsError(err.code, err.message);
+                break;
             }
         }
         // Re-emit the level list so overlay plugins can update their menus
@@ -1026,7 +1126,7 @@ export class Html5VideoBackend extends MediaElementBackend {
     }
     /** Called by the matchMedia listener when the display's HDR capability changes. */
     _onDisplayHdrChange(displayNowHdr) {
-        this._applyHdrConstraint(displayNowHdr);
+        this._applyAbrConstraints(displayNowHdr);
     }
     /**
      * Subscribe to HLS level-change signals on the current `this.hls` instance

package/dist/index.d.ts

@@ -107,6 +107,8 @@ export declare class NMVideoPlayer<T extends VideoPlaylistItem = VideoPlaylistIt
     private _checkItemEndingSoon;
     /** @internal */
     private _timeStateAt;
+    /** @internal */
+    private _mediaIsStale;
     playbackRate: {
         (): number;
         (rate: number): Promise<void>;

package/dist/index.js

@@ -260,13 +260,13 @@ export class NMVideoPlayer extends EventEmitter {
         // Authenticated media servers need the Authorization header on every
         // hls.js manifest/segment request. The provider reads the auth config
         // lazily so getter-style tokens (Vue refs, stores) stay live.
-        instance.setAuthHeaderProvider?.(async () => {
-            const bearer = this.options?.auth?.bearerToken;
-            if (!bearer)
-                return undefined;
-            const token = typeof bearer === 'function' ? await bearer() : bearer;
-            return token ? `Bearer ${token}` : undefined;
-        });
+        // Read per request rather than captured, so a consumer whose token or
+        // rule changes mid-session is not answered from a stale closure.
+        instance.setAuthHeaderProvider?.((url) => this.options?.auth?.mediaAuthorization?.(url));
+        // Consumer's HDR-on-SDR policy, read once here rather than normalized
+        // into `options` — `hdrDecision`'s own default ('play') applies at the
+        // point of use when this was never pushed at all.
+        instance.setHdrOnSdrFallback?.(this.options?.hdrOnSdr ?? 'play');
         // Mount the ResizeObserver that keeps videoRect() fresh. Done here so
         // the observer sees the real video element immediately after backend init.
         this._mountVideoRectObserver();
@@ -356,6 +356,15 @@ export class NMVideoPlayer extends EventEmitter {
             this.emit('subtitleCue', data);
         });
         instance.on('timeupdate', () => {
+            // Between a `next()` and the incoming item's mount, this element is
+            // still the OUTGOING item's — the cursor already moved. Publishing
+            // its position here hands every listener the previous item's
+            // position stamped with the new item's identity. Optional call:
+            // the dependency range admits a core that predates the reader, and
+            // an older core must degrade to the old behaviour, not throw on
+            // every tick.
+            if (this._mediaIsStale?.())
+                return;
             const currentTime = instance.currentTime();
             const duration = instance.duration();
             // The payload is core's full TimeState snapshot, built from the
@@ -698,9 +707,23 @@ composeMixins(NMVideoPlayer.prototype, ...playerCoreMethods);
 {
     const composedDispose = NMVideoPlayer.prototype.dispose;
     NMVideoPlayer.prototype.dispose = async function () {
+        // The container id is released before the first await, not after the
+        // teardown resolves. Consumers re-create on the same container in the
+        // same tick — a responsive view handing `#player1` from its desktop
+        // variant to its mobile one does exactly that — and the registry still
+        // held this player, so they were given back the very instance they had
+        // just asked to dispose. `setup()` then threw `already-setup`, and the
+        // throw left that player attached and playing with nobody holding a
+        // reference to stop it.
+        const claimedId = this.playerId;
+        _instances.delete(claimedId);
         await composedDispose.call(this);
-        if (this.phase() !== 'disposed')
-            return; // beforeDispose was prevented — backend + registry stay intact
+        if (this.phase() !== 'disposed') {
+            // beforeDispose was prevented — the player is still alive, so it
+            // takes its id back and the backend stays intact.
+            _instances.set(claimedId, this);
+            return;
+        }
         this._disposeBackend();
     };
 }