@videojs/spf 10.0.0-beta.9 → 10.0.0-rc.2

package/dist/dev/playback/adapters/hls-background-video/host.js

@@ -0,0 +1,56 @@
+//#region src/playback/adapters/hls-background-video/host.ts
+/**
+* The `<video>` binding a background video uses: somewhere to keep the attached element, and the four properties the
+* Media fixes on it.
+*
+* That is the whole surface anything here reaches. The engine drives playback, the element exposes `src` and nothing
+* else, and the background player subscribes to no store features, so nothing asks a background video for
+* `currentTime`, `play()`, picture-in-picture, fullscreen, forwarded events, or media components. Holding the host to
+* what is reachable is what keeps this entry free of `@videojs/media`, and small enough to suit a component whose whole
+* pitch is its size.
+*
+* An `EventTarget`, because a Media is one: the store and the element layers take anything they attach as an event
+* source, and inheriting the three methods satisfies that for free rather than by stubbing them.
+*
+* ⚠️ It still implements too little to carry the rest of the media surface, which bounds what may consume it: a store
+* feature reading a property outside this set gets `undefined` rather than an error. A Media needing more of that
+* surface belongs on a host that provides it.
+*/
+var BackgroundVideoHost = class extends EventTarget {
+	#target = null;
+	attach(target) {
+		if (!target || this.#target === target) return;
+		this.#target = target;
+	}
+	detach() {
+		this.#target = null;
+	}
+	get loop() {
+		return this.#target?.loop ?? false;
+	}
+	set loop(value) {
+		if (this.#target) this.#target.loop = value;
+	}
+	get muted() {
+		return this.#target?.muted ?? false;
+	}
+	set muted(value) {
+		if (this.#target) this.#target.muted = value;
+	}
+	get autoplay() {
+		return this.#target?.autoplay ?? false;
+	}
+	set autoplay(value) {
+		if (this.#target) this.#target.autoplay = value;
+	}
+	get preload() {
+		return this.#target?.preload ?? "metadata";
+	}
+	set preload(value) {
+		if (this.#target) this.#target.preload = value;
+	}
+};
+//#endregion
+export { BackgroundVideoHost };
+
+//# sourceMappingURL=host.js.map

package/dist/dev/playback/adapters/hls-background-video/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","names":["#target"],"sources":["../../../../../src/playback/adapters/hls-background-video/host.ts"],"sourcesContent":["/**\n * The `<video>` binding a background video uses: somewhere to keep the attached element, and the four properties the\n * Media fixes on it.\n *\n * That is the whole surface anything here reaches. The engine drives playback, the element exposes `src` and nothing\n * else, and the background player subscribes to no store features, so nothing asks a background video for\n * `currentTime`, `play()`, picture-in-picture, fullscreen, forwarded events, or media components. Holding the host to\n * what is reachable is what keeps this entry free of `@videojs/media`, and small enough to suit a component whose whole\n * pitch is its size.\n *\n * An `EventTarget`, because a Media is one: the store and the element layers take anything they attach as an event\n * source, and inheriting the three methods satisfies that for free rather than by stubbing them.\n *\n * ⚠️ It still implements too little to carry the rest of the media surface, which bounds what may consume it: a store\n * feature reading a property outside this set gets `undefined` rather than an error. A Media needing more of that\n * surface belongs on a host that provides it.\n */\nexport class BackgroundVideoHost extends EventTarget {\n  #target: HTMLVideoElement | null = null;\n\n  attach(target: HTMLVideoElement): void {\n    if (!target || this.#target === target) return;\n\n    this.#target = target;\n  }\n\n  detach(): void {\n    this.#target = null;\n  }\n\n  // Read back off the element rather than stored, so they describe what is\n  // playing instead of what was asked for — see the adapter's note on why the\n  // Media declares none of these itself.\n  get loop(): boolean {\n    return this.#target?.loop ?? false;\n  }\n\n  set loop(value: boolean) {\n    if (this.#target) this.#target.loop = value;\n  }\n\n  get muted(): boolean {\n    return this.#target?.muted ?? false;\n  }\n\n  set muted(value: boolean) {\n    if (this.#target) this.#target.muted = value;\n  }\n\n  get autoplay(): boolean {\n    return this.#target?.autoplay ?? false;\n  }\n\n  set autoplay(value: boolean) {\n    if (this.#target) this.#target.autoplay = value;\n  }\n\n  get preload(): HTMLVideoElement['preload'] {\n    return this.#target?.preload ?? 'metadata';\n  }\n\n  set preload(value: HTMLVideoElement['preload']) {\n    if (this.#target) this.#target.preload = value;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,IAAa,sBAAb,cAAyC,YAAY;CACnD,UAAmC;CAEnC,OAAO,QAAgC;EACrC,IAAI,CAAC,UAAU,KAAKA,YAAY,QAAQ;EAExC,KAAKA,UAAU;CACjB;CAEA,SAAe;EACb,KAAKA,UAAU;CACjB;CAKA,IAAI,OAAgB;EAClB,OAAO,KAAKA,SAAS,QAAQ;CAC/B;CAEA,IAAI,KAAK,OAAgB;EACvB,IAAI,KAAKA,SAAS,KAAKA,QAAQ,OAAO;CACxC;CAEA,IAAI,QAAiB;EACnB,OAAO,KAAKA,SAAS,SAAS;CAChC;CAEA,IAAI,MAAM,OAAgB;EACxB,IAAI,KAAKA,SAAS,KAAKA,QAAQ,QAAQ;CACzC;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAKA,SAAS,YAAY;CACnC;CAEA,IAAI,SAAS,OAAgB;EAC3B,IAAI,KAAKA,SAAS,KAAKA,QAAQ,WAAW;CAC5C;CAEA,IAAI,UAAuC;EACzC,OAAO,KAAKA,SAAS,WAAW;CAClC;CAEA,IAAI,QAAQ,OAAoC;EAC9C,IAAI,KAAKA,SAAS,KAAKA,QAAQ,UAAU;CAC3C;AACF"}

package/dist/dev/playback/adapters/hls-background-video/mixin.d.ts

@@ -0,0 +1,69 @@
+import { Composition } from "../../../core/composition/create-composition.js";
+import { HlsVideoMediaError } from "../hls-video/error-surface.js";
+import { BackgroundVideoEngineContext, BackgroundVideoEngineState } from "../../engines/hls/engine-background-video.js";
+import { Constructor, MixinReturn } from "@videojs/utils/types";
+//#region src/playback/adapters/hls-background-video/mixin.d.ts
+interface HlsBackgroundVideoAdapterProps {
+  src: string;
+}
+interface HlsBackgroundVideoAdapterAPI extends HlsBackgroundVideoAdapterProps {
+  readonly engine: Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext>;
+  readonly error: HlsVideoMediaError | null;
+  attach(mediaElement: HTMLMediaElement): void;
+  detach(): void;
+  destroy(): void;
+  play(): Promise<void>;
+}
+/**
+ * Mixin that adds the background-video SPF playback engine to any base class, for an HLS URL.
+ *
+ * `src` is the whole input surface, and `error` is the one output: nothing about an unplayable source reaches the media
+ * element on its own here — an unsupported container, encryption with no EME, and an undecodable codec all leave
+ * `HTMLMediaElement.error` null with the element stalled at `readyState 0` (measured on Chromium and WebKit) — so a
+ * consumer that watched only the `<video>` would see a source that never appears and never says why. The engine reports
+ * each condition onto `engine.state.errors` and logs it; this adapter promotes the first fatal one, mapping it the same
+ * way the video and audio Medias map theirs. See `internal/design/spf/features/errors.md`.
+ *
+ * Selection pins the largest rendition that _fits the screen_, and holds it for the session. The manifest is still the
+ * better place to narrow further: a delivery param — `?max_resolution=720p` on a Mux stream URL, for one — keeps the
+ * renditions it excludes out of the manifest entirely, rather than fetched-then-unpicked.
+ *
+ * The pin is given up, never moved, if the pick turns out to be unplayable: the container is only known once a media
+ * playlist resolves, which is after the pick is made, so the selection clears rather than quietly appending bytes
+ * nothing can decode.
+ *
+ * `<mux-background-video>` in html and react is this same Media under a Mux-flavored name — an alias, not a variant.
+ * Nothing about the surface changes with the name.
+ *
+ * Everything else the use case fixes rather than exposes: video-only, looping, muted, autoplaying, loading as soon as
+ * there is a source. `attach` writes that onto the element and nothing here declares `loop` / `muted` / `autoplay` /
+ * `preload` of its own — a host-bound Media inherits all four from the host already, and shadowing them with fixed
+ * values would only make reads describe an intention rather than what the element is doing.
+ *
+ * A new src re-resolves the presentation, tearing down the state, SourceBuffers, and in-flight requests the previous
+ * one built before the next begins. The engine instance and the attached media element are both kept, so neither has to
+ * be rewired.
+ *
+ * @example
+ *   class HlsBackgroundVideoAdapter extends HlsBackgroundVideoMixin(BackgroundVideoHost) {}
+ *
+ *   const media = new HlsBackgroundVideoAdapter();
+ *   media.attach(document.querySelector('video'));
+ *   media.src = 'https://stream.mux.com/PLAYBACK_ID.m3u8?max_resolution=720p';
+ *   media.play();
+ *
+ * @fires error - Fired when a fatal condition is reported. Read `error` for it.
+ */
+declare function HlsBackgroundVideoMixin<Base extends Constructor<any>>(BaseClass: Base): MixinReturn<Base, HlsBackgroundVideoAdapterAPI> & {
+  readonly defaultProps: HlsBackgroundVideoAdapterProps;
+};
+declare const HlsBackgroundVideoAdapterCore_base: Constructor<{} & HlsBackgroundVideoAdapterAPI, any[]> & Omit<{
+  new (): {};
+}, "prototype"> & {
+  readonly defaultProps: HlsBackgroundVideoAdapterProps;
+};
+/** Standalone SPF background-video adapter with no base class. */
+declare class HlsBackgroundVideoAdapterCore extends HlsBackgroundVideoAdapterCore_base {}
+//#endregion
+export { HlsBackgroundVideoAdapterAPI, HlsBackgroundVideoAdapterCore, HlsBackgroundVideoAdapterProps, HlsBackgroundVideoMixin, type HlsVideoMediaError };
+//# sourceMappingURL=mixin.d.ts.map

package/dist/dev/playback/adapters/hls-background-video/mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixin.d.ts","names":[],"sources":["../../../../../src/playback/adapters/hls-background-video/mixin.ts"],"mappings":";;;;;UA0BiB;EACf;;UAGe,qCAAqC;WAC3C,QAAQ,YAAY,4BAA4B;WAChD,OAAO;EAChB,OAAO,cAAc;EACrB;EACA;EACA,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmEM,wBAAwB,aAAa,kBAAkB,WAAW,OAsMpC,YAAY,MAAM;WACnD,cAAc;;;;;WAAA,cAAA;;;cAKd,sCAAsC"}

package/dist/dev/playback/adapters/hls-background-video/mixin.js

@@ -0,0 +1,191 @@
+import { effect } from "../../../core/signals/effect.js";
+import { SVTA_NO_SUPPORTED_VIDEO_TRACK, SVTA_UNSUPPORTED_DRM_SYSTEM, SVTA_UNSUPPORTED_PLAYBACK_FEATURE, SVTA_UNSUPPORTED_VIDEO_FORMAT } from "../../../media/errors.js";
+import { createBackgroundVideoEngine } from "../../engines/hls/engine-background-video.js";
+import { UNPLAYABLE_SOURCE_MESSAGE } from "../../primitives/error-messages.js";
+import { firstFatal, hasUnsupportedFeatureCause } from "../hls-video/error-surface.js";
+//#region src/playback/adapters/hls-background-video/mixin.ts
+/**
+* Which reported conditions this composition treats as **fatal** — the ones that reach `error` and fire `'error'`.
+* Severity isn't part of an SVTA code (§Approach: "impact varies with player implementation"), so it's decided at this
+* boundary rather than by the reporter.
+*
+* **Causes are fatal here, unlike on the other two adapters.** There, a cause is context — one unplayable rendition
+* doesn't fail a source whose others still play, and a verdict follows if the type empties. In the pinned variant a
+* cause _is_ the verdict: only the pinned rendition's playlist is ever resolved, so a cause can only be about the pick
+* itself, and dropping that pick is final — nothing here re-picks (that is what `switchVideoTrack` exists for, and this
+* engine doesn't compose it). Measured on Chromium: an MPEG-TS source reports 1004 and an encrypted one 4008, each with
+* no verdict behind it, and the element then sits at `readyState 0` with `error` null forever.
+*
+* The verdict is still listed, for the shapes that report nothing else: no video renditions at all, or a ladder pruned
+* before anything resolves — both of which `reportAbsentTrackType` covers from the tail of the constraint chain.
+*
+* First-fatal-wins then surfaces the cause rather than the verdict when both are present, which is the more specific of
+* the two.
+*/
+const FATAL_SVTA_CODES = /* @__PURE__ */ new Set([
+	SVTA_NO_SUPPORTED_VIDEO_TRACK,
+	SVTA_UNSUPPORTED_VIDEO_FORMAT,
+	SVTA_UNSUPPORTED_DRM_SYSTEM
+]);
+/**
+* Mixin that adds the background-video SPF playback engine to any base class, for an HLS URL.
+*
+* `src` is the whole input surface, and `error` is the one output: nothing about an unplayable source reaches the media
+* element on its own here — an unsupported container, encryption with no EME, and an undecodable codec all leave
+* `HTMLMediaElement.error` null with the element stalled at `readyState 0` (measured on Chromium and WebKit) — so a
+* consumer that watched only the `<video>` would see a source that never appears and never says why. The engine reports
+* each condition onto `engine.state.errors` and logs it; this adapter promotes the first fatal one, mapping it the same
+* way the video and audio Medias map theirs. See `internal/design/spf/features/errors.md`.
+*
+* Selection pins the largest rendition that _fits the screen_, and holds it for the session. The manifest is still the
+* better place to narrow further: a delivery param — `?max_resolution=720p` on a Mux stream URL, for one — keeps the
+* renditions it excludes out of the manifest entirely, rather than fetched-then-unpicked.
+*
+* The pin is given up, never moved, if the pick turns out to be unplayable: the container is only known once a media
+* playlist resolves, which is after the pick is made, so the selection clears rather than quietly appending bytes
+* nothing can decode.
+*
+* `<mux-background-video>` in html and react is this same Media under a Mux-flavored name — an alias, not a variant.
+* Nothing about the surface changes with the name.
+*
+* Everything else the use case fixes rather than exposes: video-only, looping, muted, autoplaying, loading as soon as
+* there is a source. `attach` writes that onto the element and nothing here declares `loop` / `muted` / `autoplay` /
+* `preload` of its own — a host-bound Media inherits all four from the host already, and shadowing them with fixed
+* values would only make reads describe an intention rather than what the element is doing.
+*
+* A new src re-resolves the presentation, tearing down the state, SourceBuffers, and in-flight requests the previous
+* one built before the next begins. The engine instance and the attached media element are both kept, so neither has to
+* be rewired.
+*
+* @example
+*   class HlsBackgroundVideoAdapter extends HlsBackgroundVideoMixin(BackgroundVideoHost) {}
+*
+*   const media = new HlsBackgroundVideoAdapter();
+*   media.attach(document.querySelector('video'));
+*   media.src = 'https://stream.mux.com/PLAYBACK_ID.m3u8?max_resolution=720p';
+*   media.play();
+*
+* @fires error - Fired when a fatal condition is reported. Read `error` for it.
+*/
+function HlsBackgroundVideoMixin(BaseClass) {
+	class HlsBackgroundVideoImpl extends BaseClass {
+		static defaultProps = { src: "" };
+		#engine;
+		#config;
+		#signals;
+		#error = null;
+		/**
+		* The _reported_ condition currently surfaced, which is what the re-fire latch keys on. Not `#error.code`: that's
+		* the code this adapter chose to surface, and the substitution below can make the two differ.
+		*/
+		#reportedCode = null;
+		#stopErrorSync;
+		/** Pending loadstart listener from a deferred play() retry, if any. */
+		#loadstartListener = null;
+		constructor(...args) {
+			super(...args);
+			const { config } = args?.[0] ?? {};
+			this.#config = config;
+			this.#engine = this.#createEngine();
+			this.#stopErrorSync = effect(() => {
+				const errors = this.#signals.state.errors.get();
+				this.#setError(firstFatal(errors, FATAL_SVTA_CODES), errors);
+			});
+		}
+		get engine() {
+			return this.#engine;
+		}
+		/**
+		* The current fatal condition, or `null`. Only _fatal_ ones appear here — the engine reports non-fatal ones too
+		* (they stay in `engine.state.errors`), and promoting them would say playback had failed when it hadn't. Which ones
+		* are fatal is wider here than on the video and audio Medias; see {@link FATAL_SVTA_CODES}. Resets per source.
+		* Fires `'error'` when set.
+		*
+		* Mapped the same way theirs are: a sequence holding an unimplemented-capability cause surfaces as
+		* {@link SVTA_UNSUPPORTED_PLAYBACK_FEATURE} (99001) with the specifics logged, because "this player can't play this
+		* source" is what a consumer can act on, where a raw container or DRM code only says what to go and look up.
+		*/
+		get error() {
+			return this.#error;
+		}
+		#setError(reported, errors) {
+			if (!reported) {
+				this.#error = null;
+				this.#reportedCode = null;
+				return;
+			}
+			if (this.#reportedCode === reported.code) return;
+			this.#reportedCode = reported.code;
+			console.error(UNPLAYABLE_SOURCE_MESSAGE, { conditions: errors });
+			this.#error = {
+				code: hasUnsupportedFeatureCause(errors) ? SVTA_UNSUPPORTED_PLAYBACK_FEATURE : reported.code,
+				message: reported.message ?? "",
+				...reported.data === void 0 ? {} : { data: reported.data }
+			};
+			this.dispatchEvent?.(new Event("error"));
+		}
+		attach(mediaElement) {
+			super.attach?.(mediaElement);
+			mediaElement.loop = true;
+			mediaElement.muted = true;
+			mediaElement.autoplay = true;
+			mediaElement.preload = "auto";
+			this.#signals.context.mediaElement.set(mediaElement);
+		}
+		detach() {
+			this.#cancelPendingPlay();
+			this.#signals.context.mediaElement.set(void 0);
+			super.detach?.();
+		}
+		destroy() {
+			this.#cancelPendingPlay();
+			this.#stopErrorSync();
+			this.#engine.destroy();
+		}
+		get src() {
+			return this.#signals.state.presentation.get()?.url ?? "";
+		}
+		set src(value) {
+			if (value === this.src) return;
+			this.#cancelPendingPlay();
+			this.#signals.state.presentation.set(value ? { url: value } : void 0);
+		}
+		async play() {
+			const mediaElement = this.#signals.context.mediaElement.get();
+			if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("HlsBackgroundVideoAdapterCore: no media element attached"));
+			try {
+				return await mediaElement.play();
+			} catch (err) {
+				if (this.src) return new Promise((resolve, reject) => {
+					const listener = () => {
+						this.#loadstartListener = null;
+						mediaElement.play().then(resolve, reject);
+					};
+					this.#loadstartListener = listener;
+					mediaElement.addEventListener("loadstart", listener, { once: true });
+				});
+				throw err;
+			}
+		}
+		#createEngine() {
+			return createBackgroundVideoEngine({
+				...this.#config,
+				onSignalsReady: (signals) => {
+					this.#signals = signals;
+				}
+			});
+		}
+		#cancelPendingPlay() {
+			if (!this.#loadstartListener) return;
+			this.#signals.context.mediaElement.get()?.removeEventListener("loadstart", this.#loadstartListener);
+			this.#loadstartListener = null;
+		}
+	}
+	return HlsBackgroundVideoImpl;
+}
+/** Standalone SPF background-video adapter with no base class. */
+var HlsBackgroundVideoAdapterCore = class extends HlsBackgroundVideoMixin(class {}) {};
+//#endregion
+export { HlsBackgroundVideoAdapterCore, HlsBackgroundVideoMixin };
+
+//# sourceMappingURL=mixin.js.map

package/dist/dev/playback/adapters/hls-background-video/mixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixin.js","names":["#config","#engine","#createEngine","#stopErrorSync","#signals","#setError","#error","#reportedCode","#cancelPendingPlay","#loadstartListener"],"sources":["../../../../../src/playback/adapters/hls-background-video/mixin.ts"],"sourcesContent":["import type { Constructor, MixinReturn } from '@videojs/utils/types';\n\nimport type { Composition } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport {\n  SVTA_NO_SUPPORTED_VIDEO_TRACK,\n  SVTA_UNSUPPORTED_DRM_SYSTEM,\n  SVTA_UNSUPPORTED_PLAYBACK_FEATURE,\n  SVTA_UNSUPPORTED_VIDEO_FORMAT,\n  type SvtaError,\n} from '../../../media/errors';\nimport {\n  type BackgroundVideoEngineConfig,\n  type BackgroundVideoEngineContext,\n  type BackgroundVideoEngineSignals,\n  type BackgroundVideoEngineState,\n  createBackgroundVideoEngine,\n} from '../../engines/hls/engine-background-video';\nimport { UNPLAYABLE_SOURCE_MESSAGE } from '../../primitives/error-messages';\nimport { firstFatal, type HlsVideoMediaError, hasUnsupportedFeatureCause } from '../hls-video/error-surface';\n\n// The same error shape the video and audio Medias expose, under the name they\n// publish it as — one type for all three surfaces rather than a background-flavored\n// copy of it.\nexport type { HlsVideoMediaError } from '../hls-video/error-surface';\n\nexport interface HlsBackgroundVideoAdapterProps {\n  src: string;\n}\n\nexport interface HlsBackgroundVideoAdapterAPI extends HlsBackgroundVideoAdapterProps {\n  readonly engine: Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext>;\n  readonly error: HlsVideoMediaError | null;\n  attach(mediaElement: HTMLMediaElement): void;\n  detach(): void;\n  destroy(): void;\n  play(): Promise<void>;\n}\n\n/**\n * Which reported conditions this composition treats as **fatal** — the ones that reach `error` and fire `'error'`.\n * Severity isn't part of an SVTA code (§Approach: \"impact varies with player implementation\"), so it's decided at this\n * boundary rather than by the reporter.\n *\n * **Causes are fatal here, unlike on the other two adapters.** There, a cause is context — one unplayable rendition\n * doesn't fail a source whose others still play, and a verdict follows if the type empties. In the pinned variant a\n * cause _is_ the verdict: only the pinned rendition's playlist is ever resolved, so a cause can only be about the pick\n * itself, and dropping that pick is final — nothing here re-picks (that is what `switchVideoTrack` exists for, and this\n * engine doesn't compose it). Measured on Chromium: an MPEG-TS source reports 1004 and an encrypted one 4008, each with\n * no verdict behind it, and the element then sits at `readyState 0` with `error` null forever.\n *\n * The verdict is still listed, for the shapes that report nothing else: no video renditions at all, or a ladder pruned\n * before anything resolves — both of which `reportAbsentTrackType` covers from the tail of the constraint chain.\n *\n * First-fatal-wins then surfaces the cause rather than the verdict when both are present, which is the more specific of\n * the two.\n */\nconst FATAL_SVTA_CODES: ReadonlySet<number> = new Set<number>([\n  SVTA_NO_SUPPORTED_VIDEO_TRACK,\n  SVTA_UNSUPPORTED_VIDEO_FORMAT,\n  SVTA_UNSUPPORTED_DRM_SYSTEM,\n]);\n\n/**\n * Mixin that adds the background-video SPF playback engine to any base class, for an HLS URL.\n *\n * `src` is the whole input surface, and `error` is the one output: nothing about an unplayable source reaches the media\n * element on its own here — an unsupported container, encryption with no EME, and an undecodable codec all leave\n * `HTMLMediaElement.error` null with the element stalled at `readyState 0` (measured on Chromium and WebKit) — so a\n * consumer that watched only the `<video>` would see a source that never appears and never says why. The engine reports\n * each condition onto `engine.state.errors` and logs it; this adapter promotes the first fatal one, mapping it the same\n * way the video and audio Medias map theirs. See `internal/design/spf/features/errors.md`.\n *\n * Selection pins the largest rendition that _fits the screen_, and holds it for the session. The manifest is still the\n * better place to narrow further: a delivery param — `?max_resolution=720p` on a Mux stream URL, for one — keeps the\n * renditions it excludes out of the manifest entirely, rather than fetched-then-unpicked.\n *\n * The pin is given up, never moved, if the pick turns out to be unplayable: the container is only known once a media\n * playlist resolves, which is after the pick is made, so the selection clears rather than quietly appending bytes\n * nothing can decode.\n *\n * `<mux-background-video>` in html and react is this same Media under a Mux-flavored name — an alias, not a variant.\n * Nothing about the surface changes with the name.\n *\n * Everything else the use case fixes rather than exposes: video-only, looping, muted, autoplaying, loading as soon as\n * there is a source. `attach` writes that onto the element and nothing here declares `loop` / `muted` / `autoplay` /\n * `preload` of its own — a host-bound Media inherits all four from the host already, and shadowing them with fixed\n * values would only make reads describe an intention rather than what the element is doing.\n *\n * A new src re-resolves the presentation, tearing down the state, SourceBuffers, and in-flight requests the previous\n * one built before the next begins. The engine instance and the attached media element are both kept, so neither has to\n * be rewired.\n *\n * @example\n *   class HlsBackgroundVideoAdapter extends HlsBackgroundVideoMixin(BackgroundVideoHost) {}\n *\n *   const media = new HlsBackgroundVideoAdapter();\n *   media.attach(document.querySelector('video'));\n *   media.src = 'https://stream.mux.com/PLAYBACK_ID.m3u8?max_resolution=720p';\n *   media.play();\n *\n * @fires error - Fired when a fatal condition is reported. Read `error` for it.\n */\nexport function HlsBackgroundVideoMixin<Base extends Constructor<any>>(BaseClass: Base) {\n  class HlsBackgroundVideoImpl extends BaseClass {\n    static readonly defaultProps: HlsBackgroundVideoAdapterProps = {\n      src: '',\n    };\n\n    #engine: Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext>;\n    #config: BackgroundVideoEngineConfig;\n    #signals!: BackgroundVideoEngineSignals;\n    #error: HlsVideoMediaError | null = null;\n    /**\n     * The _reported_ condition currently surfaced, which is what the re-fire latch keys on. Not `#error.code`: that's\n     * the code this adapter chose to surface, and the substitution below can make the two differ.\n     */\n    #reportedCode: number | null = null;\n    #stopErrorSync: () => void;\n\n    /** Pending loadstart listener from a deferred play() retry, if any. */\n    #loadstartListener: (() => void) | null = null;\n\n    constructor(...args: any[]) {\n      super(...args);\n\n      const { config } = args?.[0] ?? {};\n\n      this.#config = config;\n      this.#engine = this.#createEngine();\n\n      // Promote the first fatal condition out of the engine's reported sequence\n      // onto this surface. Clearing rides the same signal: `collectErrors` resets\n      // the slot per source, so a new source starts with no error without this\n      // needing its own source-change hook.\n      this.#stopErrorSync = effect(() => {\n        const errors = this.#signals.state.errors.get();\n\n        this.#setError(firstFatal(errors, FATAL_SVTA_CODES), errors);\n      });\n    }\n\n    get engine(): Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext> {\n      return this.#engine;\n    }\n\n    /**\n     * The current fatal condition, or `null`. Only _fatal_ ones appear here — the engine reports non-fatal ones too\n     * (they stay in `engine.state.errors`), and promoting them would say playback had failed when it hadn't. Which ones\n     * are fatal is wider here than on the video and audio Medias; see {@link FATAL_SVTA_CODES}. Resets per source.\n     * Fires `'error'` when set.\n     *\n     * Mapped the same way theirs are: a sequence holding an unimplemented-capability cause surfaces as\n     * {@link SVTA_UNSUPPORTED_PLAYBACK_FEATURE} (99001) with the specifics logged, because \"this player can't play this\n     * source\" is what a consumer can act on, where a raw container or DRM code only says what to go and look up.\n     */\n    get error(): HlsVideoMediaError | null {\n      return this.#error;\n    }\n\n    #setError(reported: SvtaError | undefined, errors: readonly SvtaError[] | undefined): void {\n      if (!reported) {\n        // Cleared (new source). No event: `'error'` announces a failure, and\n        // consumers reset their own copy on source change.\n        this.#error = null;\n        this.#reportedCode = null;\n        return;\n      }\n\n      // Keyed on the code, not the object: a later append re-runs this effect\n      // with an equal-but-new array, and re-firing `'error'` for a condition\n      // already surfaced would look like a second failure.\n      if (this.#reportedCode === reported.code) return;\n\n      this.#reportedCode = reported.code;\n\n      // Logged for every fatal condition, not just the substituted ones: a source\n      // with no video renditions is as dead as an unplayable container, and it\n      // would otherwise reach a developer as a bare code. One generic sentence\n      // rather than one per case — the conditions beside it carry the specifics.\n      //\n      // Prose stays here rather than on `error.message`, matching the other two:\n      // viewer-facing copy is the consumer's to localize, and a background video\n      // has no chrome to put it in anyway.\n      console.error(UNPLAYABLE_SOURCE_MESSAGE, { conditions: errors });\n\n      this.#error = {\n        code: hasUnsupportedFeatureCause(errors) ? SVTA_UNSUPPORTED_PLAYBACK_FEATURE : reported.code,\n        message: reported.message ?? '',\n        ...(reported.data === undefined ? {} : { data: reported.data }),\n      };\n      // Optional-chained: with an EventTarget-less base (`HlsBackgroundVideoAdapterCore`\n      // standalone) there's nowhere to dispatch.\n      this.dispatchEvent?.(new Event('error'));\n    }\n\n    // -------------------------------------------------------------------------\n    // Media element lifecycle\n    // -------------------------------------------------------------------------\n\n    attach(mediaElement: HTMLMediaElement): void {\n      super.attach?.(mediaElement);\n      // The one place the fixed behavior is stated. Muted and autoplay are what\n      // let it start without a gesture, loop is the defining behavior, and\n      // `preload` says out loud what the engine does regardless — it subtracts\n      // preload monitoring and loads from the moment it has a source.\n      mediaElement.loop = true;\n      mediaElement.muted = true;\n      mediaElement.autoplay = true;\n      mediaElement.preload = 'auto';\n\n      this.#signals.context.mediaElement.set(mediaElement);\n    }\n\n    detach(): void {\n      this.#cancelPendingPlay();\n      this.#signals.context.mediaElement.set(undefined);\n      super.detach?.();\n    }\n\n    destroy(): void {\n      this.#cancelPendingPlay();\n      this.#stopErrorSync();\n      this.#engine.destroy();\n    }\n\n    // -------------------------------------------------------------------------\n    // src — synchronous IDL attribute (WHATWG §4.8.11.2)\n    // -------------------------------------------------------------------------\n\n    get src(): string {\n      return this.#signals.state.presentation.get()?.url ?? '';\n    }\n\n    set src(value: string) {\n      // Same line the HLS Medias draw: the presentation is set from a fresh\n      // object every time, so re-resolving a URL already playing would restart\n      // it for no reason.\n      if (value === this.src) return;\n\n      this.#cancelPendingPlay();\n      this.#signals.state.presentation.set(value ? { url: value } : undefined);\n    }\n\n    // -------------------------------------------------------------------------\n    // play() — WHATWG §4.8.11.8\n    // Delegates to the attached media element's native play().\n    // -------------------------------------------------------------------------\n\n    async play(): Promise<void> {\n      const mediaElement = this.#signals.context.mediaElement.get();\n      if (!mediaElement) return Promise.reject(new Error('HlsBackgroundVideoAdapterCore: no media element attached'));\n\n      try {\n        return await mediaElement.play();\n      } catch (err) {\n        // If we have a pending HLS source, the rejection may be because MSE\n        // hasn't attached a blob URL yet. Wait for loadstart (src assigned by\n        // MSE setup) and retry once.\n        if (this.src) {\n          return new Promise<void>((resolve, reject) => {\n            const listener = () => {\n              this.#loadstartListener = null;\n              mediaElement.play().then(resolve, reject);\n            };\n\n            this.#loadstartListener = listener;\n            mediaElement.addEventListener('loadstart', listener, { once: true });\n          });\n        }\n\n        throw err;\n      }\n    }\n\n    // -------------------------------------------------------------------------\n    // Private\n    // -------------------------------------------------------------------------\n\n    #createEngine(): Composition<BackgroundVideoEngineState, BackgroundVideoEngineContext> {\n      // No selection config of its own: the engine's default rule chain already\n      // narrows to the largest rendition that fits the screen, which is exactly\n      // what this adapter used to hand over as a bespoke picker.\n      return createBackgroundVideoEngine({\n        ...this.#config,\n        onSignalsReady: (signals) => {\n          this.#signals = signals;\n        },\n      });\n    }\n\n    #cancelPendingPlay(): void {\n      if (!this.#loadstartListener) return;\n\n      const mediaElement = this.#signals.context.mediaElement.get();\n\n      mediaElement?.removeEventListener('loadstart', this.#loadstartListener);\n      this.#loadstartListener = null;\n    }\n  }\n\n  return HlsBackgroundVideoImpl as unknown as MixinReturn<Base, HlsBackgroundVideoAdapterAPI> & {\n    readonly defaultProps: HlsBackgroundVideoAdapterProps;\n  };\n}\n\n/** Standalone SPF background-video adapter with no base class. */\nexport class HlsBackgroundVideoAdapterCore extends HlsBackgroundVideoMixin(class {}) {}\n"],"mappings":"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"}

package/dist/dev/playback/adapters/hls-video/adapter.d.ts

@@ -0,0 +1,11 @@
+import { HlsVideoAdapterAPI, HlsVideoAdapterProps } from "./mixin.js";
+import { HTMLVideoAdapter } from "@videojs/media/dom";
+//#region src/playback/adapters/hls-video/adapter.d.ts
+declare const HlsVideoAdapterBase: import("@videojs/media/media-tracks").WithMediaTracks<import("@videojs/utils/types").Constructor<HTMLVideoAdapter & HlsVideoAdapterAPI, any[]> & Omit<typeof HTMLVideoAdapter, "prototype"> & {
+  readonly alternativeMediaSuggestion: string | undefined;
+  readonly defaultProps: HlsVideoAdapterProps;
+}>;
+declare class HlsVideoAdapter extends HlsVideoAdapterBase {}
+//#endregion
+export { HlsVideoAdapter };
+//# sourceMappingURL=adapter.d.ts.map

package/dist/dev/playback/adapters/hls-video/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","names":[],"sources":["../../../../../src/playback/adapters/hls-video/adapter.ts"],"mappings":";;;cAMM,2DAAmB,+CAAA,YAAA,mBAAA,6BAAA,YAAA;;yBAAA;;cAEZ,wBAAwB"}

package/dist/dev/playback/adapters/hls-video/adapter.js

@@ -0,0 +1,11 @@
+import { HlsVideoMixin } from "./mixin.js";
+import { HlsVideoMediaTracksMixin } from "./media-tracks.js";
+import { HTMLVideoAdapter } from "@videojs/media/dom";
+import { MediaTracksMixin } from "@videojs/media/media-tracks";
+//#region src/playback/adapters/hls-video/adapter.ts
+const HlsVideoAdapterBase = HlsVideoMediaTracksMixin(MediaTracksMixin(HlsVideoMixin(HTMLVideoAdapter)));
+var HlsVideoAdapter = class extends HlsVideoAdapterBase {};
+//#endregion
+export { HlsVideoAdapter };
+
+//# sourceMappingURL=adapter.js.map

package/dist/dev/playback/adapters/hls-video/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":[],"sources":["../../../../../src/playback/adapters/hls-video/adapter.ts"],"sourcesContent":["import { HTMLVideoAdapter } from '@videojs/media/dom';\nimport { MediaTracksMixin } from '@videojs/media/media-tracks';\n\nimport { HlsVideoMediaTracksMixin } from './media-tracks';\nimport { HlsVideoMixin } from './mixin';\n\nconst HlsVideoAdapterBase = HlsVideoMediaTracksMixin(MediaTracksMixin(HlsVideoMixin(HTMLVideoAdapter)));\n\nexport class HlsVideoAdapter extends HlsVideoAdapterBase {}\n"],"mappings":";;;;;AAMA,MAAM,sBAAsB,yBAAyB,iBAAiB,cAAc,gBAAgB,CAAC,CAAC;AAEtG,IAAa,kBAAb,cAAqC,oBAAoB,CAAC"}

package/dist/dev/playback/adapters/hls-video/error-surface.d.ts

@@ -0,0 +1,17 @@
+import { ErrorLike } from "@videojs/media";
+//#region src/playback/adapters/hls-video/error-surface.d.ts
+/**
+ * The error shape a media surface exposes: `@videojs/media`'s {@link ErrorLike} plus the reporter context the engine
+ * carries alongside a condition.
+ *
+ * `code` is the **SVTA code**, not a `MediaError.MEDIA_ERR_*` value. Consumers that map codes to copy currently only
+ * know 1–5, so an SVTA code falls through to showing `message`; an extensible code lookup above the engine is the
+ * follow-up that fixes it.
+ */
+interface HlsVideoMediaError extends ErrorLike {
+  /** Reporter context (which selection emptied, which track, …). */
+  readonly data?: unknown;
+}
+//#endregion
+export { HlsVideoMediaError };
+//# sourceMappingURL=error-surface.d.ts.map

package/dist/dev/playback/adapters/hls-video/error-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-surface.d.ts","names":[],"sources":["../../../../../src/playback/adapters/hls-video/error-surface.ts"],"mappings":";;;;;;;;;;UA8BiB,2BAA2B;;WAEjC"}

package/dist/dev/playback/adapters/hls-video/error-surface.js

@@ -0,0 +1,46 @@
+import { SVTA_UNSUPPORTED_AUDIO_FORMAT, SVTA_UNSUPPORTED_DRM_SYSTEM, SVTA_UNSUPPORTED_VIDEO_FORMAT } from "../../../media/errors.js";
+//#region src/playback/adapters/hls-video/error-surface.ts
+/**
+* `message`, plus the alternative-Media sentence when `media`'s class names one.
+*
+* Read off the class rather than passed in so a subclass can point at a better-equipped sibling — the SPF Mux Medias
+* name the hls.js-backed one, which plays the MPEG-TS and DRM sources SPF doesn't — without either adapter knowing that
+* sibling exists.
+*/
+function withAlternativeMediaSuggestion(message, media) {
+	const { alternativeMediaSuggestion } = media.constructor;
+	const suggestion = alternativeMediaSuggestion?.trim();
+	return suggestion ? `${message} ${suggestion}` : message;
+}
+/** The first condition `fatalCodes` covers — the root cause, not its consequences. */
+function firstFatal(errors, fatalCodes) {
+	return errors?.find((error) => fatalCodes.has(error.code));
+}
+/**
+* The causes that mean the engine has no pipeline for what the source delivers — a container it can't append, or
+* encryption it can't decrypt.
+*
+* What these have in common is that no retry, no other CDN, and no other rendition of the same source fixes them: the
+* source needs a capability this engine doesn't have. That's the distinction the surfaced code exists to draw, and it's
+* why the set is these three rather than "every cause".
+*/
+const UNSUPPORTED_FEATURE_CAUSES = /* @__PURE__ */ new Set([
+	SVTA_UNSUPPORTED_VIDEO_FORMAT,
+	SVTA_UNSUPPORTED_AUDIO_FORMAT,
+	SVTA_UNSUPPORTED_DRM_SYSTEM
+]);
+/**
+* Whether anything in the sequence is a cause of the "we don't implement this" kind.
+*
+* Deliberately `some` over the whole sequence rather than a per-type match against the verdict. A verdict means one
+* type's candidates emptied, but the _reason_ the source is unplayable can sit on another type — an audio-only source
+* whose sole rendition is encrypted empties the audio candidates, and a video source with encrypted video empties the
+* video ones. Both are the same answer to the viewer, so both get the same code.
+*/
+function hasUnsupportedFeatureCause(errors) {
+	return errors?.some((error) => UNSUPPORTED_FEATURE_CAUSES.has(error.code)) ?? false;
+}
+//#endregion
+export { firstFatal, hasUnsupportedFeatureCause, withAlternativeMediaSuggestion };
+
+//# sourceMappingURL=error-surface.js.map

package/dist/dev/playback/adapters/hls-video/error-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-surface.js","names":[],"sources":["../../../../../src/playback/adapters/hls-video/error-surface.ts"],"sourcesContent":["/**\n * The shared half of promoting reported conditions onto a media surface.\n *\n * Every adapter that has one does the same things: pick the first condition it treats as fatal, latch it so a later\n * append doesn't re-fire, and name a better-equipped Media when its own class points at one. Only the _policy_ differs\n * — which codes are fatal, which the video, audio-only, and background adapters each answer differently — so that stays\n * with each adapter and everything else lives here.\n *\n * `firstFatal` is the part all three share. The `ErrorLike` mapping below it is for the two that feed a store and a\n * dialog; the background adapter surfaces the reported condition unmapped, so it takes the picker and nothing else.\n *\n * See `internal/design/spf/features/errors.md` for the causes-vs-verdicts split this rests on.\n */\nimport type { ErrorLike } from '@videojs/media';\n\nimport {\n  SVTA_UNSUPPORTED_AUDIO_FORMAT,\n  SVTA_UNSUPPORTED_DRM_SYSTEM,\n  SVTA_UNSUPPORTED_VIDEO_FORMAT,\n  type SvtaError,\n} from '../../../media/errors';\n\n/**\n * The error shape a media surface exposes: `@videojs/media`'s {@link ErrorLike} plus the reporter context the engine\n * carries alongside a condition.\n *\n * `code` is the **SVTA code**, not a `MediaError.MEDIA_ERR_*` value. Consumers that map codes to copy currently only\n * know 1–5, so an SVTA code falls through to showing `message`; an extensible code lookup above the engine is the\n * follow-up that fixes it.\n */\nexport interface HlsVideoMediaError extends ErrorLike {\n  /** Reporter context (which selection emptied, which track, …). */\n  readonly data?: unknown;\n}\n\n/**\n * `message`, plus the alternative-Media sentence when `media`'s class names one.\n *\n * Read off the class rather than passed in so a subclass can point at a better-equipped sibling — the SPF Mux Medias\n * name the hls.js-backed one, which plays the MPEG-TS and DRM sources SPF doesn't — without either adapter knowing that\n * sibling exists.\n */\nexport function withAlternativeMediaSuggestion(message: string, media: object): string {\n  const { alternativeMediaSuggestion } = media.constructor as { alternativeMediaSuggestion?: string };\n  const suggestion = alternativeMediaSuggestion?.trim();\n\n  return suggestion ? `${message} ${suggestion}` : message;\n}\n\n/** The first condition `fatalCodes` covers — the root cause, not its consequences. */\nexport function firstFatal(\n  errors: readonly SvtaError[] | undefined,\n  fatalCodes: ReadonlySet<number>\n): SvtaError | undefined {\n  return errors?.find((error) => fatalCodes.has(error.code));\n}\n\n/**\n * The causes that mean the engine has no pipeline for what the source delivers — a container it can't append, or\n * encryption it can't decrypt.\n *\n * What these have in common is that no retry, no other CDN, and no other rendition of the same source fixes them: the\n * source needs a capability this engine doesn't have. That's the distinction the surfaced code exists to draw, and it's\n * why the set is these three rather than \"every cause\".\n */\nconst UNSUPPORTED_FEATURE_CAUSES: ReadonlySet<number> = new Set<number>([\n  SVTA_UNSUPPORTED_VIDEO_FORMAT,\n  SVTA_UNSUPPORTED_AUDIO_FORMAT,\n  SVTA_UNSUPPORTED_DRM_SYSTEM,\n]);\n\n/**\n * Whether anything in the sequence is a cause of the \"we don't implement this\" kind.\n *\n * Deliberately `some` over the whole sequence rather than a per-type match against the verdict. A verdict means one\n * type's candidates emptied, but the _reason_ the source is unplayable can sit on another type — an audio-only source\n * whose sole rendition is encrypted empties the audio candidates, and a video source with encrypted video empties the\n * video ones. Both are the same answer to the viewer, so both get the same code.\n */\nexport function hasUnsupportedFeatureCause(errors: readonly SvtaError[] | undefined): boolean {\n  return errors?.some((error) => UNSUPPORTED_FEATURE_CAUSES.has(error.code)) ?? false;\n}\n"],"mappings":";;;;;;;;;AA0CA,SAAgB,+BAA+B,SAAiB,OAAuB;CACrF,MAAM,EAAE,+BAA+B,MAAM;CAC7C,MAAM,aAAa,4BAA4B,KAAK;CAEpD,OAAO,aAAa,GAAG,QAAQ,GAAG,eAAe;AACnD;;AAGA,SAAgB,WACd,QACA,YACuB;CACvB,OAAO,QAAQ,MAAM,UAAU,WAAW,IAAI,MAAM,IAAI,CAAC;AAC3D;;;;;;;;;AAUA,MAAM,6CAAkD,IAAI,IAAY;CACtE;CACA;CACA;AACF,CAAC;;;;;;;;;AAUD,SAAgB,2BAA2B,QAAmD;CAC5F,OAAO,QAAQ,MAAM,UAAU,2BAA2B,IAAI,MAAM,IAAI,CAAC,KAAK;AAChF"}

package/dist/dev/playback/adapters/hls-video/media-tracks.d.ts

@@ -0,0 +1,21 @@
+import { Composition } from "../../../core/composition/create-composition.js";
+import { HlsVideoEngineContext, HlsVideoEngineState } from "../../engines/hls/engine.js";
+import { MediaAudioTrackCapability, MediaVideoRenditionCapability, MediaVideoTrackCapability } from "@videojs/media";
+import { Constructor } from "@videojs/utils/types";
+//#region src/playback/adapters/hls-video/media-tracks.d.ts
+type HlsVideoEngineHost = {
+  readonly engine: Composition<HlsVideoEngineState, HlsVideoEngineContext>;
+  destroy?(): void;
+};
+type MediaTracksHost = HlsVideoEngineHost & MediaVideoTrackCapability & MediaAudioTrackCapability & MediaVideoRenditionCapability;
+/**
+ * Projects the SPF engine's presentation onto the media element's `videoRenditions` / `audioTracks` lists, and wires
+ * user selection back to the engine's `userVideoTrackSelection` / `userAudioTrackSelection` signals.
+ *
+ * Requires the media-tracks mixin (track-list infrastructure) earlier in the chain so the host exposes `addVideoTrack`,
+ * `videoRenditions`, and friends.
+ */
+declare function HlsVideoMediaTracksMixin<Base extends Constructor<MediaTracksHost>>(BaseClass: Base): Base;
+//#endregion
+export { HlsVideoMediaTracksMixin };
+//# sourceMappingURL=media-tracks.d.ts.map

package/dist/dev/playback/adapters/hls-video/media-tracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-tracks.d.ts","names":[],"sources":["../../../../../src/playback/adapters/hls-video/media-tracks.ts"],"mappings":";;;;;KAoCK;WACM,QAAQ,YAAY,qBAAqB;EAClD;;KAGG,kBAAkB,qBACrB,4BACA,4BACA;;;;;;;;iBAac,yBAAyB,aAAa,YAAY,kBAAkB,WAAW,OAiLpD"}

package/dist/dev/playback/adapters/hls-video/media-tracks.js

@@ -0,0 +1,125 @@
+import { computed, untrack } from "../../../core/signals/primitives.js";
+import { effect } from "../../../core/signals/effect.js";
+import { dedupedAudioTracks, dedupedVideoTracks, findAudioTrackById, findVideoTrackById, frameRateToNumber, isSameAudioTrack, isSameVideoTrack, toUserAudioTrackSelection, toUserVideoTrackSelection } from "../../../media/media-tracks/media-tracks.js";
+//#region src/playback/adapters/hls-video/media-tracks.ts
+const toVideoKey = (rendition) => ({
+	width: rendition.width,
+	height: rendition.height,
+	bandwidth: rendition.bitrate
+});
+const toAudioKey = (track) => ({
+	language: track.language,
+	name: track.label
+});
+/** Two track lists carry the same set when their id sequences match. */
+const sameIds = (a, b) => a.length === b.length && a.every((item, i) => item.id === b[i].id);
+/**
+* Projects the SPF engine's presentation onto the media element's `videoRenditions` / `audioTracks` lists, and wires
+* user selection back to the engine's `userVideoTrackSelection` / `userAudioTrackSelection` signals.
+*
+* Requires the media-tracks mixin (track-list infrastructure) earlier in the chain so the host exposes `addVideoTrack`,
+* `videoRenditions`, and friends.
+*/
+function HlsVideoMediaTracksMixin(BaseClass) {
+	class HlsVideoMediaTracks extends BaseClass {
+		#abort = new AbortController();
+		#destroyed = false;
+		#renditions = [];
+		#audioTracks = [];
+		constructor(...args) {
+			super(...args);
+			const { state } = this.engine;
+			const { signal } = this.#abort;
+			const renditionsSignal = computed(() => dedupedVideoTracks(state.presentation.get()), { equals: sameIds });
+			const audioTracksSignal = computed(() => dedupedAudioTracks(state.presentation.get()), { equals: sameIds });
+			const reflectRenditions = () => {
+				const renditions = renditionsSignal.get();
+				this.#renditions = renditions;
+				this.#removeVideoTracks();
+				if (!renditions.length) return;
+				const videoTrack = this.addVideoTrack("main");
+				videoTrack.selected = true;
+				const resolved = untrack(() => findVideoTrackById(state.presentation.get(), state.selectedVideoTrackId.get()));
+				for (const rendition of renditions) {
+					const domRendition = videoTrack.addRendition("", rendition.width, rendition.height, rendition.codecs.join(","), rendition.bandwidth, rendition.frameRate ? frameRateToNumber(rendition.frameRate) : void 0);
+					domRendition.id = rendition.id;
+					domRendition.active = isSameVideoTrack(toVideoKey(domRendition), resolved);
+				}
+			};
+			const reflectSelectedVideo = () => {
+				const resolved = findVideoTrackById(state.presentation.get(), state.selectedVideoTrackId.get());
+				for (const rendition of this.videoRenditions) rendition.active = isSameVideoTrack(toVideoKey(rendition), resolved);
+			};
+			const reflectAudioTracks = () => {
+				const tracks = audioTracksSignal.get();
+				this.#audioTracks = tracks;
+				this.#removeAudioTracks();
+				if (!tracks.length) return;
+				const resolved = untrack(() => findAudioTrackById(state.presentation.get(), state.selectedAudioTrackId.get()));
+				for (const track of tracks) {
+					const domTrack = this.addAudioTrack(track.default ? "main" : "alternative", track.name, track.language ?? "");
+					domTrack.id = track.id;
+					domTrack.enabled = isSameAudioTrack(toAudioKey(domTrack), resolved);
+				}
+			};
+			const reflectSelectedAudio = () => {
+				const resolved = findAudioTrackById(state.presentation.get(), state.selectedAudioTrackId.get());
+				for (const track of this.audioTracks) track.enabled = isSameAudioTrack(toAudioKey(track), resolved);
+			};
+			const sourceUrl = computed(() => state.presentation.get()?.url);
+			const resetSelectionOnSourceChange = () => {
+				sourceUrl.get();
+				state.userVideoTrackSelection.set(void 0);
+				state.userAudioTrackSelection.set(void 0);
+			};
+			const effectCleanups = [
+				effect(reflectRenditions),
+				effect(reflectSelectedVideo),
+				effect(reflectAudioTracks),
+				effect(reflectSelectedAudio),
+				effect(resetSelectionOnSourceChange)
+			];
+			this.videoRenditions.addEventListener("change", this.#selectRendition, { signal });
+			this.audioTracks.addEventListener("change", this.#selectAudio, { signal });
+			signal.addEventListener("abort", () => effectCleanups.forEach((cleanup) => cleanup()), { once: true });
+		}
+		destroy() {
+			if (this.#destroyed) return;
+			this.#destroyed = true;
+			this.#abort.abort();
+			this.#removeVideoTracks();
+			this.#removeAudioTracks();
+			super.destroy?.();
+		}
+		#selectRendition = () => {
+			const { userVideoTrackSelection } = this.engine.state;
+			const index = this.videoRenditions.selectedIndex;
+			const domRendition = index < 0 ? void 0 : this.videoRenditions[index];
+			const rendition = this.#renditions.find((candidate) => candidate.id === domRendition?.id);
+			userVideoTrackSelection.set(toUserVideoTrackSelection(rendition));
+		};
+		#selectAudio = () => {
+			const { presentation, selectedAudioTrackId, userAudioTrackSelection } = this.engine.state;
+			const resolved = findAudioTrackById(presentation.get(), selectedAudioTrackId.get());
+			const current = [...this.audioTracks].find((track) => isSameAudioTrack(toAudioKey(track), resolved));
+			const enabled = [...this.audioTracks].filter((track) => track.enabled);
+			const target = enabled.find((track) => track !== current) ?? enabled[0];
+			if (!target) return;
+			for (const track of enabled) if (track !== target) track.enabled = false;
+			if (target === current) return;
+			const audioTrack = this.#audioTracks.find((candidate) => candidate.id === target.id);
+			userAudioTrackSelection.set(toUserAudioTrackSelection(audioTrack));
+		};
+		#removeVideoTracks() {
+			for (const videoTrack of [...this.videoTracks]) this.removeVideoTrack(videoTrack);
+		}
+		#removeAudioTracks() {
+			for (const audioTrack of [...this.audioTracks]) this.removeAudioTrack(audioTrack);
+		}
+	}
+	return HlsVideoMediaTracks;
+}
+//#endregion
+export { HlsVideoMediaTracksMixin };
+
+//# sourceMappingURL=media-tracks.js.map