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

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

@@ -0,0 +1 @@
+{"version":3,"file":"media-tracks.js","names":["#abort","#renditions","#removeVideoTracks","#audioTracks","#removeAudioTracks","#selectRendition","#selectAudio","#destroyed"],"sources":["../../../../../src/playback/adapters/hls-video/media-tracks.ts"],"sourcesContent":["import type {\n  AudioTrackLike,\n  MediaAudioTrackCapability,\n  MediaVideoRenditionCapability,\n  MediaVideoTrackCapability,\n  VideoRenditionLike,\n} from '@videojs/media';\nimport type { Constructor } from '@videojs/utils/types';\n\nimport type { Composition } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport { computed, untrack } from '../../../core/signals/primitives';\nimport {\n  type AudioTrack,\n  dedupedAudioTracks,\n  dedupedVideoTracks,\n  findAudioTrackById,\n  findVideoTrackById,\n  frameRateToNumber,\n  isSameAudioTrack,\n  isSameVideoTrack,\n  toUserAudioTrackSelection,\n  toUserVideoTrackSelection,\n  type VideoTrack,\n} from '../../../media/media-tracks';\nimport type { HlsVideoEngineContext, HlsVideoEngineState } from '../../engines/hls/engine';\n\n// Translate a DOM rendition/track into the SPF dedupe-key shape\nconst toVideoKey = (rendition: VideoRenditionLike) => ({\n  width: rendition.width,\n  height: rendition.height,\n  bandwidth: rendition.bitrate!,\n});\n\nconst toAudioKey = (track: AudioTrackLike) => ({ language: track.language, name: track.label });\n\ntype HlsVideoEngineHost = {\n  readonly engine: Composition<HlsVideoEngineState, HlsVideoEngineContext>;\n  destroy?(): void;\n};\n\ntype MediaTracksHost = HlsVideoEngineHost &\n  MediaVideoTrackCapability &\n  MediaAudioTrackCapability &\n  MediaVideoRenditionCapability;\n\n/** Two track lists carry the same set when their id sequences match. */\nconst sameIds = (a: { id: string }[], b: { id: string }[]): boolean =>\n  a.length === b.length && a.every((item, i) => item.id === b[i]!.id);\n\n/**\n * Projects the SPF engine's presentation onto the media element's `videoRenditions` / `audioTracks` lists, and wires\n * user selection back to the engine's `userVideoTrackSelection` / `userAudioTrackSelection` signals.\n *\n * Requires the media-tracks mixin (track-list infrastructure) earlier in the chain so the host exposes `addVideoTrack`,\n * `videoRenditions`, and friends.\n */\nexport function HlsVideoMediaTracksMixin<Base extends Constructor<MediaTracksHost>>(BaseClass: Base) {\n  class HlsVideoMediaTracks extends (BaseClass as Constructor<MediaTracksHost>) {\n    #abort = new AbortController();\n    #destroyed = false;\n    // Memoized SPF model — the last `computed` result per type — so a DOM\n    // selection maps back to the engine's match criteria by id via the SPF\n    // selection helpers (the DOM lists carry only DOM-shape props).\n    #renditions: VideoTrack[] = [];\n    #audioTracks: AudioTrack[] = [];\n\n    constructor(...args: any[]) {\n      super(...args);\n\n      const { state } = this.engine;\n      const { signal } = this.#abort;\n\n      const renditionsSignal = computed(() => dedupedVideoTracks(state.presentation.get()), { equals: sameIds });\n      const audioTracksSignal = computed(() => dedupedAudioTracks(state.presentation.get()), { equals: sameIds });\n\n      // Rebuild video renditions when the set changes; seed `active` from the\n      // current resolved selection (read untracked — `active` deltas are the\n      // reflection effect's job).\n      const reflectRenditions = () => {\n        const renditions = renditionsSignal.get();\n\n        this.#renditions = renditions;\n        this.#removeVideoTracks();\n\n        if (!renditions.length) return;\n\n        // \"video track\" here is the Media UI Extensions concept, which maps onto\n        // the SPF model differently than the name suggests:\n        //   MUE track     -> SPF selection set\n        //   MUE rendition -> SPF track\n        // @see https://github.com/video-dev/media-ui-extensions/blob/main/proposals/0011-renditions-list.md\n        //\n        // Every rendition hangs off a single \"main\" video track. Multi-track\n        // video (multiple camera angles, CMAF multi-track) isn't supported yet,\n        // so exactly one video track is always exposed; when it lands, this\n        // becomes one track (selection set) per angle.\n        const videoTrack = this.addVideoTrack('main');\n\n        videoTrack.selected = true;\n\n        const resolved = untrack(() => findVideoTrackById(state.presentation.get(), state.selectedVideoTrackId.get()));\n\n        for (const rendition of renditions) {\n          const domRendition = videoTrack.addRendition(\n            '',\n            rendition.width,\n            rendition.height,\n            rendition.codecs.join(','),\n            rendition.bandwidth,\n            rendition.frameRate ? frameRateToNumber(rendition.frameRate) : undefined\n          );\n\n          domRendition.id = rendition.id;\n          domRendition.active = isSameVideoTrack(toVideoKey(domRendition), resolved);\n        }\n      };\n\n      const reflectSelectedVideo = () => {\n        const resolved = findVideoTrackById(state.presentation.get(), state.selectedVideoTrackId.get());\n\n        for (const rendition of this.videoRenditions) {\n          rendition.active = isSameVideoTrack(toVideoKey(rendition), resolved);\n        }\n      };\n\n      // Rebuild audio tracks when the set changes; seed `enabled` from the\n      // current resolved selection.\n      const reflectAudioTracks = () => {\n        const tracks = audioTracksSignal.get();\n\n        this.#audioTracks = tracks;\n        this.#removeAudioTracks();\n\n        if (!tracks.length) return;\n\n        const resolved = untrack(() => findAudioTrackById(state.presentation.get(), state.selectedAudioTrackId.get()));\n\n        for (const track of tracks) {\n          const domTrack = this.addAudioTrack(track.default ? 'main' : 'alternative', track.name, track.language ?? '');\n\n          domTrack.id = track.id;\n          domTrack.enabled = isSameAudioTrack(toAudioKey(domTrack), resolved);\n        }\n      };\n\n      const reflectSelectedAudio = () => {\n        const resolved = findAudioTrackById(state.presentation.get(), state.selectedAudioTrackId.get());\n\n        for (const track of this.audioTracks) {\n          track.enabled = isSameAudioTrack(toAudioKey(track), resolved);\n        }\n      };\n\n      // A source change (new manifest URL) invalidates any pinned selection:\n      // rendition identity (width/height/bandwidth) and audio identity\n      // (language/name) don't reliably carry across sources, so drop both pins\n      // and let the engine re-pick for the new source.\n      const sourceUrl = computed(() => state.presentation.get()?.url);\n      const resetSelectionOnSourceChange = () => {\n        sourceUrl.get();\n        state.userVideoTrackSelection.set(undefined);\n        state.userAudioTrackSelection.set(undefined);\n      };\n\n      const effectCleanups = [\n        effect(reflectRenditions),\n        effect(reflectSelectedVideo),\n        effect(reflectAudioTracks),\n        effect(reflectSelectedAudio),\n        effect(resetSelectionOnSourceChange),\n      ];\n\n      this.videoRenditions.addEventListener('change', this.#selectRendition, { signal });\n      this.audioTracks.addEventListener('change', this.#selectAudio, { signal });\n      signal.addEventListener('abort', () => effectCleanups.forEach((cleanup) => cleanup()), { once: true });\n    }\n\n    destroy(): void {\n      if (this.#destroyed) return;\n\n      this.#destroyed = true;\n      this.#abort.abort();\n      this.#removeVideoTracks();\n      this.#removeAudioTracks();\n      super.destroy?.();\n    }\n\n    // Manual quality pin → the chosen rendition's width/height/bandwidth as the\n    // match criteria (the properties renditions were deduped on).\n    // `selectedIndex === -1` (Auto) clears the pin, resuming ABR.\n    #selectRendition = () => {\n      const { userVideoTrackSelection } = this.engine.state;\n      const index = this.videoRenditions.selectedIndex;\n      const domRendition = index < 0 ? undefined : this.videoRenditions[index];\n      const rendition = this.#renditions.find((candidate) => candidate.id === domRendition?.id);\n\n      userVideoTrackSelection.set(toUserVideoTrackSelection(rendition));\n    };\n\n    #selectAudio = () => {\n      const { presentation, selectedAudioTrackId, userAudioTrackSelection } = this.engine.state;\n      const resolved = findAudioTrackById(presentation.get(), selectedAudioTrackId.get());\n      const current = [...this.audioTracks].find((track) => isSameAudioTrack(toAudioKey(track), resolved));\n\n      // `enabled` is not exclusive like video `selected`, so prefer a newly\n      // enabled track over the one that is already playing.\n      const enabled = [...this.audioTracks].filter((track) => track.enabled);\n      const target = enabled.find((track) => track !== current) ?? enabled[0];\n      if (!target) return;\n\n      // Disable the rest so future change events resolve unambiguously.\n      for (const track of enabled) {\n        if (track !== target) track.enabled = false;\n      }\n\n      // Skip the write when the enabled track is already the resolved one\n      // that's this projection's own reflection (or a no-op re-affirm), not a user switch.\n      if (target === current) return;\n\n      const audioTrack = this.#audioTracks.find((candidate) => candidate.id === target.id);\n\n      userAudioTrackSelection.set(toUserAudioTrackSelection(audioTrack));\n    };\n\n    #removeVideoTracks() {\n      for (const videoTrack of [...this.videoTracks]) this.removeVideoTrack(videoTrack);\n    }\n\n    #removeAudioTracks() {\n      for (const audioTrack of [...this.audioTracks]) this.removeAudioTrack(audioTrack);\n    }\n  }\n\n  return HlsVideoMediaTracks as unknown as Base;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,62 @@
+import { Composition } from "../../../core/composition/create-composition.js";
+import { HlsVideoMediaError } from "./error-surface.js";
+import { HlsVideoEngineContext, HlsVideoEngineState } from "../../engines/hls/engine.js";
+import { MediaStreamType } from "@videojs/media";
+import { Constructor, MixinReturn } from "@videojs/utils/types";
+//#region src/playback/adapters/hls-video/mixin.d.ts
+/**
+ * The media-level stream type: the engine's detected stream type (`'live'` / `'on-demand'`) plus `'unknown'` for "no
+ * playlist parsed yet." `@videojs/media`'s {@link MediaStreamType} itself, kept under its own name because that is what
+ * this adapter's `streamType` property is documented against.
+ */
+type HlsVideoMediaStreamType = MediaStreamType;
+interface HlsVideoAdapterProps {
+  src: string;
+  preload: '' | 'none' | 'metadata' | 'auto';
+  disableRemotePlayback: boolean;
+  streamType: HlsVideoMediaStreamType;
+}
+interface HlsVideoAdapterAPI extends HlsVideoAdapterProps {
+  readonly engine: Composition<HlsVideoEngineState, HlsVideoEngineContext>;
+  readonly error: HlsVideoMediaError | null;
+  readonly liveEdgeStart: number;
+  readonly targetLiveWindow: number;
+  attach(mediaElement: HTMLMediaElement): void;
+  detach(): void;
+  destroy(): void;
+  play(): Promise<void>;
+}
+/**
+ * Mixin that adds SPF playback engine behavior to any base class.
+ *
+ * Implements the src/play() contract per the WHATWG HTML spec so that SPF can be used anywhere a media element API is
+ * expected.
+ *
+ * A single engine instance is created at construction and recycled across src changes.
+ *
+ * @example
+ *   class HlsVideoAdapter extends HlsVideoMixin(HTMLVideoAdapter) {}
+ *
+ *   const media = new HlsVideoAdapter();
+ *   media.attach(document.querySelector('video'));
+ *   media.src = 'https://stream.mux.com/abc123.m3u8';
+ *
+ * @fires streamtypechange - Fired when the detected stream type changes. Read `streamType` for the new value.
+ * @fires targetlivewindowchange - Fired when the target live window changes. Read `targetLiveWindow` for the new value.
+ * @fires error - Fired when a fatal condition is reported. Read `error` for it.
+ */
+declare function HlsVideoMixin<Base extends Constructor<any>>(BaseClass: Base): MixinReturn<Base, HlsVideoAdapterAPI> & {
+  readonly alternativeMediaSuggestion: string | undefined;
+  readonly defaultProps: HlsVideoAdapterProps;
+};
+declare const HlsVideoAdapterCore_base: Constructor<{} & HlsVideoAdapterAPI, any[]> & Omit<{
+  new (): {};
+}, "prototype"> & {
+  readonly alternativeMediaSuggestion: string | undefined;
+  readonly defaultProps: HlsVideoAdapterProps;
+};
+/** Standalone SPF media adapter with no base class. */
+declare class HlsVideoAdapterCore extends HlsVideoAdapterCore_base {}
+//#endregion
+export { HlsVideoAdapterAPI, HlsVideoAdapterCore, HlsVideoAdapterProps, type HlsVideoMediaError, HlsVideoMediaStreamType, HlsVideoMixin };
+//# sourceMappingURL=mixin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mixin.d.ts","names":[],"sources":["../../../../../src/playback/adapters/hls-video/mixin.ts"],"mappings":";;;;;;;;;;;KA6CY,0BAA0B;UAIrB;EACf;EACA;EACA;EACA,YAAY;;UAGG,2BAA2B;WACjC,QAAQ,YAAY,qBAAqB;WACzC,OAAO;WACP;WACA;EACT,OAAO,cAAc;EACrB;EACA;EACA,QAAQ;;;;;;;;;;;;;;;;;;;;;iBA8DM,cAAc,aAAa,kBAAkB,WAAW,OAkYpC,YAAY,MAAM;WACzC;WACA,cAAc;;;;;WADc;WACd,cAAA;;;cAKd,4BAA4B"}

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

@@ -0,0 +1,299 @@
+import { effect } from "../../../core/signals/effect.js";
+import { deriveStreamType, getMediaPlaylistMetadata, isResolvedPresentation, isResolvedTrack } from "../../../media/types/index.js";
+import { findTrackById } from "../../../media/utils/tracks.js";
+import { SVTA_NO_SUPPORTED_AUDIO_TRACK, SVTA_NO_SUPPORTED_VIDEO_TRACK, SVTA_UNSUPPORTED_PLAYBACK_FEATURE } from "../../../media/errors.js";
+import { resolveLiveLatency } from "../../../media/hls/reload-policy.js";
+import { getLiveEdge, liveTrackId } from "../../primitives/live-window.js";
+import { createHlsVideoEngine } from "../../engines/hls/engine.js";
+import { DVR_EXPERIMENTAL_MESSAGE, LOW_LATENCY_UNSUPPORTED_MESSAGE, UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE } from "../../primitives/error-messages.js";
+import { firstFatal, hasUnsupportedFeatureCause, withAlternativeMediaSuggestion } from "./error-surface.js";
+import { MediaStreamTypes } from "@videojs/media";
+//#region src/playback/adapters/hls-video/mixin.ts
+/**
+* `targetLiveWindow` per the media-ui-extensions live-edge proposal: `NaN` for on-demand (or nothing resolved yet), `0`
+* for standard sliding-window live, `Infinity` for DVR (`#EXT-X-PLAYLIST-TYPE:EVENT` — the window grows from the
+* start). Read from the timeline-bearing track's playlist metadata.
+*/
+function deriveTargetLiveWindow(presentation, trackId) {
+	if (!isResolvedPresentation(presentation) || !trackId) return NaN;
+	const track = findTrackById(presentation, trackId);
+	if (!track || !isResolvedTrack(track)) return NaN;
+	const metadata = getMediaPlaylistMetadata(track);
+	if (!metadata) return NaN;
+	if (metadata.playlistType === "EVENT") return Number.POSITIVE_INFINITY;
+	return deriveStreamType(metadata) === "live" ? 0 : NaN;
+}
+/**
+* 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"), and here it also varies
+* by composition, so it's decided at this boundary rather than by the reporter.
+*
+* An allow-list, deliberately: only _verdicts_ are here. The per-rendition causes `resolve-track` reports (unsupported
+* format, unsupported DRM) stay in the sequence as context — one unplayable rendition doesn't fail the source, and
+* promoting a cause would put a dialog over a mixed source that goes on to play.
+*/
+const FATAL_SVTA_CODES = /* @__PURE__ */ new Set([SVTA_NO_SUPPORTED_VIDEO_TRACK, SVTA_NO_SUPPORTED_AUDIO_TRACK]);
+/**
+* Mixin that adds SPF playback engine behavior to any base class.
+*
+* Implements the src/play() contract per the WHATWG HTML spec so that SPF can be used anywhere a media element API is
+* expected.
+*
+* A single engine instance is created at construction and recycled across src changes.
+*
+* @example
+*   class HlsVideoAdapter extends HlsVideoMixin(HTMLVideoAdapter) {}
+*
+*   const media = new HlsVideoAdapter();
+*   media.attach(document.querySelector('video'));
+*   media.src = 'https://stream.mux.com/abc123.m3u8';
+*
+* @fires streamtypechange - Fired when the detected stream type changes. Read `streamType` for the new value.
+* @fires targetlivewindowchange - Fired when the target live window changes. Read `targetLiveWindow` for the new value.
+* @fires error - Fired when a fatal condition is reported. Read `error` for it.
+*/
+function HlsVideoMixin(BaseClass) {
+	class HlsVideoImpl extends BaseClass {
+		static defaultProps = {
+			src: "",
+			preload: "",
+			disableRemotePlayback: false,
+			streamType: MediaStreamTypes.UNKNOWN
+		};
+		/**
+		* A complete sentence naming the Media to reach for when this one can't play a source — `Try the hls.js-backed Mux
+		* media instead: import the hls-js flavor in place of the spf one.` Appended to the copy this adapter surfaces, and
+		* to the notices it logs. Name the flavor, not an import path: a Media is reached through several packages, each
+		* with its own counterpart.
+		*
+		* Empty here: `hls-video` has no better-equipped sibling to point at. A Media that does (a Mux Video built on this
+		* engine, whose hls.js-backed counterpart plays MPEG-TS and DRM) overrides this static, and its copy gains the
+		* second sentence with no other change.
+		*/
+		static get alternativeMediaSuggestion() {}
+		#engine;
+		#config;
+		#signals;
+		#preload = HlsVideoImpl.defaultProps.preload;
+		#disableRemotePlayback = HlsVideoImpl.defaultProps.disableRemotePlayback;
+		#streamType = HlsVideoImpl.defaultProps.streamType;
+		#isUserStreamType = false;
+		#targetLiveWindow = NaN;
+		#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 a later cause can change the choice for a condition already
+		* announced.
+		*/
+		#reportedCode = null;
+		/** Notices already logged for the current source; cleared when it unloads. */
+		#noticed = /* @__PURE__ */ new Set();
+		#stopLiveSync;
+		#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.#stopLiveSync = effect(() => {
+				const presentation = this.#signals.state.presentation.get();
+				this.#setDetectedStreamType(presentation?.streamType ?? MediaStreamTypes.UNKNOWN);
+				this.#setTargetLiveWindow(deriveTargetLiveWindow(presentation, liveTrackId(this.#signals.state)));
+				this.#reportDeliveryNotices(presentation);
+			});
+			this.#stopErrorSync = effect(() => {
+				const errors = this.#signals.state.errors.get();
+				this.#setError(firstFatal(errors, FATAL_SVTA_CODES), errors);
+			});
+		}
+		/**
+		* Underlying playback engine — the low-level SPF reactive composition that drives playback. An advanced escape
+		* hatch for direct engine access; normal playback is driven through this element's own properties and methods.
+		*/
+		get engine() {
+			return this.#engine;
+		}
+		/**
+		* The current fatal error, or `null`. Only _fatal_ conditions appear here — the engine reports non-fatal ones too
+		* (they stay in `engine.state.errors`), and promoting them would tell a consumer playback had failed when it
+		* hadn't. Resets per source. Fires `'error'` when set.
+		*/
+		get error() {
+			return this.#error;
+		}
+		/**
+		* The source's stream type — `'live'`, `'on-demand'`, or `'unknown'` until a media playlist has been parsed.
+		* Setting a non-`'unknown'` value pins a user override (detection stops updating it); setting `'unknown'` reverts
+		* to the engine's detected value.
+		*/
+		get streamType() {
+			return this.#streamType;
+		}
+		set streamType(value) {
+			if (value === MediaStreamTypes.UNKNOWN) {
+				this.#isUserStreamType = false;
+				this.#updateStreamType(this.#signals.state.presentation.get()?.streamType ?? MediaStreamTypes.UNKNOWN);
+				return;
+			}
+			this.#isUserStreamType = true;
+			this.#updateStreamType(value);
+		}
+		/**
+		* Presentation time marking the start of the live-edge window — playback at `currentTime >= liveEdgeStart` counts
+		* as "at the live edge" (the same target the engine's `seekToLiveEdge` seeks to: window end − HOLD-BACK). `NaN`
+		* when the stream isn't live or nothing is resolved yet. Derived at read time from the engine's live window — no
+		* change event; re-read on `timeupdate`/`progress` (as the store's live feature does).
+		*/
+		get liveEdgeStart() {
+			return getLiveEdge({
+				state: this.#signals.state,
+				config: { resolveLiveLatency }
+			})?.liveEdgeStart ?? NaN;
+		}
+		/**
+		* The target live window: `NaN` for on-demand (or unknown), `0` for standard sliding-window live, `Infinity` for
+		* DVR (`#EXT-X-PLAYLIST-TYPE:EVENT`). Fires `targetlivewindowchange` on change.
+		*/
+		get targetLiveWindow() {
+			return this.#targetLiveWindow;
+		}
+		#setDetectedStreamType(value) {
+			if (this.#isUserStreamType) return;
+			this.#updateStreamType(value);
+		}
+		#updateStreamType(value) {
+			if (this.#streamType === value) return;
+			this.#streamType = value;
+			this.dispatchEvent?.(new Event("streamtypechange"));
+		}
+		#setTargetLiveWindow(value) {
+			if (Object.is(this.#targetLiveWindow, value)) return;
+			this.#targetLiveWindow = value;
+			this.dispatchEvent?.(new Event("targetlivewindowchange"));
+		}
+		#setError(reported, errors) {
+			if (!reported) {
+				this.#error = null;
+				this.#reportedCode = null;
+				return;
+			}
+			if (this.#reportedCode === reported.code) return;
+			this.#reportedCode = reported.code;
+			const unsupported = hasUnsupportedFeatureCause(errors);
+			if (unsupported) console.error(this.#withSuggestion(UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE), { conditions: errors });
+			this.#error = {
+				code: unsupported ? 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);
+			this.#signals.context.mediaElement.set(mediaElement);
+		}
+		detach() {
+			this.#cancelPendingPlay();
+			this.#signals.context.mediaElement.set(void 0);
+			super.detach?.();
+		}
+		destroy() {
+			this.#cancelPendingPlay();
+			this.#stopLiveSync();
+			this.#stopErrorSync();
+			this.#engine.destroy();
+		}
+		/** Preload type (`'none'` / `'metadata'` / `'auto'`). */
+		get preload() {
+			return this.#preload;
+		}
+		set preload(value) {
+			this.#preload = value;
+			if (value) this.#signals.state.preload.set(value);
+		}
+		get disableRemotePlayback() {
+			return this.#disableRemotePlayback;
+		}
+		set disableRemotePlayback(value) {
+			this.#disableRemotePlayback = value;
+			this.#signals.state.disableRemotePlayback.set(value);
+		}
+		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);
+		}
+		play() {
+			const mediaElement = this.#signals.context.mediaElement.get();
+			if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("HlsVideoAdapterCore: no media element attached"));
+			this.#signals.state.loadActivated.set(true);
+			return 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;
+			});
+		}
+		/** `message`, plus the alternative-Media sentence when this class names one. */
+		#withSuggestion(message) {
+			return withAlternativeMediaSuggestion(message, this);
+		}
+		/**
+		* Log what this engine is delivering differently from what the playlist asked for. Neither condition stops
+		* playback, so neither is an error — they go to the console rather than the error surface.
+		*
+		* Once per source, not per parse: a live playlist reloads every target duration, and the timeline track re-parses
+		* on each one. Keyed on the notice rather than latched with a boolean so the two are independent, and cleared when
+		* the presentation unresolves so the next source starts quiet.
+		*/
+		#reportDeliveryNotices(presentation) {
+			if (!isResolvedPresentation(presentation)) {
+				this.#noticed.clear();
+				return;
+			}
+			const trackId = liveTrackId(this.#signals.state);
+			const track = trackId ? findTrackById(presentation, trackId) : void 0;
+			if (!track || !isResolvedTrack(track)) return;
+			const metadata = getMediaPlaylistMetadata(track);
+			if (!metadata) return;
+			if (metadata.lowLatency && !this.#noticed.has("lowLatency")) {
+				this.#noticed.add("lowLatency");
+				console.warn(this.#withSuggestion(LOW_LATENCY_UNSUPPORTED_MESSAGE));
+			}
+			if (metadata.playlistType === "EVENT" && !this.#noticed.has("dvr")) {
+				this.#noticed.add("dvr");
+				console.warn(this.#withSuggestion(DVR_EXPERIMENTAL_MESSAGE));
+			}
+		}
+		#createEngine() {
+			return createHlsVideoEngine({
+				...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 HlsVideoImpl;
+}
+/** Standalone SPF media adapter with no base class. */
+var HlsVideoAdapterCore = class extends HlsVideoMixin(class {}) {};
+//#endregion
+export { HlsVideoAdapterCore, HlsVideoMixin };
+
+//# sourceMappingURL=mixin.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mixin.js","names":["#engine","#config","#createEngine","#stopLiveSync","#signals","#setDetectedStreamType","#setTargetLiveWindow","#reportDeliveryNotices","#stopErrorSync","#setError","#error","#streamType","#isUserStreamType","#updateStreamType","#targetLiveWindow","#reportedCode","#withSuggestion","#cancelPendingPlay","#preload","#disableRemotePlayback","#loadstartListener","#noticed"],"sources":["../../../../../src/playback/adapters/hls-video/mixin.ts"],"sourcesContent":["import { type MediaStreamType, MediaStreamTypes } from '@videojs/media';\nimport 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_AUDIO_TRACK,\n  SVTA_NO_SUPPORTED_VIDEO_TRACK,\n  SVTA_UNSUPPORTED_PLAYBACK_FEATURE,\n  type SvtaError,\n} from '../../../media/errors';\nimport { resolveLiveLatency } from '../../../media/hls/reload-policy';\nimport {\n  deriveStreamType,\n  getMediaPlaylistMetadata,\n  isResolvedPresentation,\n  isResolvedTrack,\n  type MaybeResolvedPresentation,\n} from '../../../media/types';\nimport { findTrackById } from '../../../media/utils/tracks';\nimport {\n  createHlsVideoEngine,\n  type HlsVideoEngineConfig,\n  type HlsVideoEngineContext,\n  type HlsVideoEngineSignals,\n  type HlsVideoEngineState,\n} from '../../engines/hls/engine';\nimport {\n  DVR_EXPERIMENTAL_MESSAGE,\n  LOW_LATENCY_UNSUPPORTED_MESSAGE,\n  UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE,\n} from '../../primitives/error-messages';\nimport { getLiveEdge, type LiveWindowState, liveTrackId } from '../../primitives/live-window';\nimport {\n  firstFatal,\n  type HlsVideoMediaError,\n  hasUnsupportedFeatureCause,\n  withAlternativeMediaSuggestion,\n} from './error-surface';\n\n/**\n * The media-level stream type: the engine's detected stream type (`'live'` / `'on-demand'`) plus `'unknown'` for \"no\n * playlist parsed yet.\" `@videojs/media`'s {@link MediaStreamType} itself, kept under its own name because that is what\n * this adapter's `streamType` property is documented against.\n */\nexport type HlsVideoMediaStreamType = MediaStreamType;\n\nexport type { HlsVideoMediaError } from './error-surface';\n\nexport interface HlsVideoAdapterProps {\n  src: string;\n  preload: '' | 'none' | 'metadata' | 'auto';\n  disableRemotePlayback: boolean;\n  streamType: HlsVideoMediaStreamType;\n}\n\nexport interface HlsVideoAdapterAPI extends HlsVideoAdapterProps {\n  readonly engine: Composition<HlsVideoEngineState, HlsVideoEngineContext>;\n  readonly error: HlsVideoMediaError | null;\n  readonly liveEdgeStart: number;\n  readonly targetLiveWindow: number;\n  attach(mediaElement: HTMLMediaElement): void;\n  detach(): void;\n  destroy(): void;\n  play(): Promise<void>;\n}\n\n/**\n * `targetLiveWindow` per the media-ui-extensions live-edge proposal: `NaN` for on-demand (or nothing resolved yet), `0`\n * for standard sliding-window live, `Infinity` for DVR (`#EXT-X-PLAYLIST-TYPE:EVENT` — the window grows from the\n * start). Read from the timeline-bearing track's playlist metadata.\n */\nfunction deriveTargetLiveWindow(\n  presentation: MaybeResolvedPresentation | undefined,\n  trackId: string | undefined\n): number {\n  if (!isResolvedPresentation(presentation) || !trackId) return Number.NaN;\n\n  const track = findTrackById(presentation, trackId);\n  if (!track || !isResolvedTrack(track)) return Number.NaN;\n\n  const metadata = getMediaPlaylistMetadata(track);\n  if (!metadata) return Number.NaN;\n\n  if (metadata.playlistType === 'EVENT') return Number.POSITIVE_INFINITY;\n\n  return deriveStreamType(metadata) === 'live' ? 0 : Number.NaN;\n}\n\n// ============================================================================\n// Error surface\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\"), and here it also varies\n * by composition, so it's decided at this boundary rather than by the reporter.\n *\n * An allow-list, deliberately: only _verdicts_ are here. The per-rendition causes `resolve-track` reports (unsupported\n * format, unsupported DRM) stay in the sequence as context — one unplayable rendition doesn't fail the source, and\n * promoting a cause would put a dialog over a mixed source that goes on to play.\n */\nconst FATAL_SVTA_CODES: ReadonlySet<number> = new Set<number>([\n  SVTA_NO_SUPPORTED_VIDEO_TRACK,\n  SVTA_NO_SUPPORTED_AUDIO_TRACK,\n]);\n\n/**\n * Mixin that adds SPF playback engine behavior to any base class.\n *\n * Implements the src/play() contract per the WHATWG HTML spec so that SPF can be used anywhere a media element API is\n * expected.\n *\n * A single engine instance is created at construction and recycled across src changes.\n *\n * @example\n *   class HlsVideoAdapter extends HlsVideoMixin(HTMLVideoAdapter) {}\n *\n *   const media = new HlsVideoAdapter();\n *   media.attach(document.querySelector('video'));\n *   media.src = 'https://stream.mux.com/abc123.m3u8';\n *\n * @fires streamtypechange - Fired when the detected stream type changes. Read `streamType` for the new value.\n * @fires targetlivewindowchange - Fired when the target live window changes. Read `targetLiveWindow` for the new value.\n * @fires error - Fired when a fatal condition is reported. Read `error` for it.\n */\nexport function HlsVideoMixin<Base extends Constructor<any>>(BaseClass: Base) {\n  class HlsVideoImpl extends BaseClass {\n    static readonly defaultProps: HlsVideoAdapterProps = {\n      src: '',\n      preload: '',\n      disableRemotePlayback: false,\n      streamType: MediaStreamTypes.UNKNOWN,\n    };\n\n    /**\n     * A complete sentence naming the Media to reach for when this one can't play a source — `Try the hls.js-backed Mux\n     * media instead: import the hls-js flavor in place of the spf one.` Appended to the copy this adapter surfaces, and\n     * to the notices it logs. Name the flavor, not an import path: a Media is reached through several packages, each\n     * with its own counterpart.\n     *\n     * Empty here: `hls-video` has no better-equipped sibling to point at. A Media that does (a Mux Video built on this\n     * engine, whose hls.js-backed counterpart plays MPEG-TS and DRM) overrides this static, and its copy gains the\n     * second sentence with no other change.\n     */\n    static get alternativeMediaSuggestion(): string | undefined {\n      return undefined;\n    }\n\n    readonly #engine: Composition<HlsVideoEngineState, HlsVideoEngineContext>;\n    #config: HlsVideoEngineConfig;\n    #signals!: HlsVideoEngineSignals;\n    #preload: '' | 'none' | 'metadata' | 'auto' = HlsVideoImpl.defaultProps.preload;\n    #disableRemotePlayback: boolean = HlsVideoImpl.defaultProps.disableRemotePlayback;\n    #streamType: HlsVideoMediaStreamType = HlsVideoImpl.defaultProps.streamType;\n    #isUserStreamType = false;\n    #targetLiveWindow = Number.NaN;\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 a later cause can change the choice for a condition already\n     * announced.\n     */\n    #reportedCode: number | null = null;\n    /** Notices already logged for the current source; cleared when it unloads. */\n    #noticed = new Set<string>();\n    #stopLiveSync: () => void;\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      // Mirror the engine's live/stream-type detection onto the media surface,\n      // firing the change events the store features listen for. One effect over\n      // the presentation + selection signals; `liveEdgeStart` is deliberately\n      // NOT cached here — it's derived at read time (the store re-reads it on\n      // `timeupdate`/`progress`), so a sliding window needs no event churn.\n      this.#stopLiveSync = effect(() => {\n        const presentation = this.#signals.state.presentation.get();\n\n        this.#setDetectedStreamType(presentation?.streamType ?? MediaStreamTypes.UNKNOWN);\n        this.#setTargetLiveWindow(deriveTargetLiveWindow(presentation, liveTrackId(this.#signals.state)));\n        this.#reportDeliveryNotices(presentation);\n      });\n\n      // Promote the first fatal condition out of the engine's reported sequence\n      // onto the media surface. Clearing rides the same signal: `collectErrors`\n      // resets the slot per source, so a new source starts with no error without\n      // this 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    /**\n     * Underlying playback engine — the low-level SPF reactive composition that drives playback. An advanced escape\n     * hatch for direct engine access; normal playback is driven through this element's own properties and methods.\n     */\n    get engine(): Composition<HlsVideoEngineState, HlsVideoEngineContext> {\n      return this.#engine;\n    }\n\n    // -------------------------------------------------------------------------\n    // Live surface — streamType / targetLiveWindow / liveEdgeStart\n    // (the MediaStreamTypeCapability + MediaLiveCapability contract the player\n    // store's stream-type and live features consume)\n    // -------------------------------------------------------------------------\n\n    /**\n     * The current fatal error, or `null`. Only _fatal_ conditions appear here — the engine reports non-fatal ones too\n     * (they stay in `engine.state.errors`), and promoting them would tell a consumer playback had failed when it\n     * hadn't. Resets per source. Fires `'error'` when set.\n     */\n    get error(): HlsVideoMediaError | null {\n      return this.#error;\n    }\n\n    /**\n     * The source's stream type — `'live'`, `'on-demand'`, or `'unknown'` until a media playlist has been parsed.\n     * Setting a non-`'unknown'` value pins a user override (detection stops updating it); setting `'unknown'` reverts\n     * to the engine's detected value.\n     */\n    get streamType(): HlsVideoMediaStreamType {\n      return this.#streamType;\n    }\n\n    set streamType(value: HlsVideoMediaStreamType) {\n      if (value === MediaStreamTypes.UNKNOWN) {\n        this.#isUserStreamType = false;\n        this.#updateStreamType(this.#signals.state.presentation.get()?.streamType ?? MediaStreamTypes.UNKNOWN);\n        return;\n      }\n\n      this.#isUserStreamType = true;\n      this.#updateStreamType(value);\n    }\n\n    /**\n     * Presentation time marking the start of the live-edge window — playback at `currentTime >= liveEdgeStart` counts\n     * as \"at the live edge\" (the same target the engine's `seekToLiveEdge` seeks to: window end − HOLD-BACK). `NaN`\n     * when the stream isn't live or nothing is resolved yet. Derived at read time from the engine's live window — no\n     * change event; re-read on `timeupdate`/`progress` (as the store's live feature does).\n     */\n    get liveEdgeStart(): number {\n      const edge = getLiveEdge({\n        state: this.#signals.state as LiveWindowState,\n        config: { resolveLiveLatency },\n      });\n\n      return edge?.liveEdgeStart ?? Number.NaN;\n    }\n\n    /**\n     * The target live window: `NaN` for on-demand (or unknown), `0` for standard sliding-window live, `Infinity` for\n     * DVR (`#EXT-X-PLAYLIST-TYPE:EVENT`). Fires `targetlivewindowchange` on change.\n     */\n    get targetLiveWindow(): number {\n      return this.#targetLiveWindow;\n    }\n\n    #setDetectedStreamType(value: HlsVideoMediaStreamType): void {\n      if (this.#isUserStreamType) return;\n\n      this.#updateStreamType(value);\n    }\n\n    #updateStreamType(value: HlsVideoMediaStreamType): void {\n      if (this.#streamType === value) return;\n\n      this.#streamType = value;\n      // Optional-chained: with an EventTarget-less base (`HlsVideoAdapterCore`\n      // standalone) there's nowhere to dispatch; hosts forward it to listeners.\n      this.dispatchEvent?.(new Event('streamtypechange'));\n    }\n\n    #setTargetLiveWindow(value: number): void {\n      if (Object.is(this.#targetLiveWindow, value)) return;\n\n      this.#targetLiveWindow = value;\n      this.dispatchEvent?.(new Event('targetlivewindowchange'));\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      // A verdict says a type emptied; the causes say whether anything could\n      // have played it. When they include something this engine simply doesn't\n      // implement, that's the more useful thing to tell a consumer, so it\n      // replaces the verdict's code on the surface.\n      const unsupported = hasUnsupportedFeatureCause(errors);\n\n      if (unsupported) {\n        // The only place this engine explains itself in prose, and it's a\n        // console: the viewer-facing sentence is the consumer's to localize from\n        // the code. Conditions ride along structured so the specifics stay\n        // inspectable.\n        console.error(this.#withSuggestion(UNSUPPORTED_PLAYBACK_FEATURE_MESSAGE), { conditions: errors });\n      }\n\n      this.#error = {\n        code: unsupported ? SVTA_UNSUPPORTED_PLAYBACK_FEATURE : reported.code,\n        message: reported.message ?? '',\n        ...(reported.data === undefined ? {} : { data: reported.data }),\n      };\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      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.#stopLiveSync();\n      this.#stopErrorSync();\n      this.#engine.destroy();\n    }\n\n    // -------------------------------------------------------------------------\n    // preload — synchronous IDL attribute (WHATWG §4.8.11.2)\n    // -------------------------------------------------------------------------\n\n    /** Preload type (`'none'` / `'metadata'` / `'auto'`). */\n    get preload(): '' | 'none' | 'metadata' | 'auto' {\n      return this.#preload;\n    }\n\n    set preload(value: '' | 'none' | 'metadata' | 'auto') {\n      this.#preload = value;\n\n      if (value) {\n        this.#signals.state.preload.set(value);\n      }\n      // value = '' resets the IDL mirror (so `get preload` reflects '') but does\n      // not patch state — the engine keeps its current preload until an explicit\n      // W3C value replaces it.\n    }\n\n    // -------------------------------------------------------------------------\n    // disableRemotePlayback — synchronous IDL attribute (WHATWG Remote Playback)\n    // Author intent for whether the AirPlay/remote picker is offered. Mirrors\n    // the DOM attribute name; the value flows to `state.disableRemotePlayback`,\n    // which `setupAirPlay` reads to honor an explicit opt-out. The underlying\n    // <video>'s own `disableRemotePlayback` stays programmatically managed\n    // (ManagedMediaSource needs it `true` to open; AirPlay flips it `false` once\n    // the source is open), so author intent and the effective flag stay distinct.\n    // -------------------------------------------------------------------------\n\n    get disableRemotePlayback(): boolean {\n      return this.#disableRemotePlayback;\n    }\n\n    set disableRemotePlayback(value: boolean) {\n      this.#disableRemotePlayback = value;\n      this.#signals.state.disableRemotePlayback.set(value);\n    }\n\n    // -------------------------------------------------------------------------\n    // src — synchronous IDL attribute (WHATWG §4.8.11.2)\n    // Each assignment overwrites the engine's presentation state in place. The\n    // resolver FSM routes back through teardown → rebuild on the same engine,\n    // mirroring how the browser's load algorithm resets media state on src change\n    // — without recreating the engine or re-capturing its signals. Setting an\n    // empty src un-resolves the presentation, tearing the current source down to\n    // the engine's fresh-but-attached \"no source\" state.\n    // -------------------------------------------------------------------------\n\n    get src(): string {\n      return this.#signals.state.presentation.get()?.url ?? '';\n    }\n\n    set src(value: string) {\n      // Assigning the URL already playing is not a request to reload it. The\n      // presentation is set from a fresh object every time, so re-resolving an\n      // unchanged URL restarts playback — which is what a caller changing only\n      // the parts of a structured source that describe images, rather than the\n      // stream, would get. The hls.js Media draws the same line: it announces\n      // every source change and loads only when the URL or engine config moves.\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    play(): Promise<void> {\n      const mediaElement = this.#signals.context.mediaElement.get();\n      if (!mediaElement) return Promise.reject(new Error('HlsVideoAdapterCore: no media element attached'));\n\n      // Signal play intent — enables loading even with preload=\"none\"\n      this.#signals.state.loadActivated.set(true);\n\n      return mediaElement.play().catch((err: unknown) => {\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\n        // by 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    /** `message`, plus the alternative-Media sentence when this class names one. */\n    #withSuggestion(message: string): string {\n      return withAlternativeMediaSuggestion(message, this);\n    }\n\n    /**\n     * Log what this engine is delivering differently from what the playlist asked for. Neither condition stops\n     * playback, so neither is an error — they go to the console rather than the error surface.\n     *\n     * Once per source, not per parse: a live playlist reloads every target duration, and the timeline track re-parses\n     * on each one. Keyed on the notice rather than latched with a boolean so the two are independent, and cleared when\n     * the presentation unresolves so the next source starts quiet.\n     */\n    #reportDeliveryNotices(presentation: MaybeResolvedPresentation | undefined): void {\n      if (!isResolvedPresentation(presentation)) {\n        this.#noticed.clear();\n        return;\n      }\n\n      const trackId = liveTrackId(this.#signals.state);\n      const track = trackId ? findTrackById(presentation, trackId) : undefined;\n      if (!track || !isResolvedTrack(track)) return;\n\n      const metadata = getMediaPlaylistMetadata(track);\n      if (!metadata) return;\n\n      if (metadata.lowLatency && !this.#noticed.has('lowLatency')) {\n        this.#noticed.add('lowLatency');\n        console.warn(this.#withSuggestion(LOW_LATENCY_UNSUPPORTED_MESSAGE));\n      }\n\n      if (metadata.playlistType === 'EVENT' && !this.#noticed.has('dvr')) {\n        this.#noticed.add('dvr');\n        console.warn(this.#withSuggestion(DVR_EXPERIMENTAL_MESSAGE));\n      }\n    }\n\n    #createEngine(): Composition<HlsVideoEngineState, HlsVideoEngineContext> {\n      return createHlsVideoEngine({\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  // `MixinReturn` sources statics from `Base`, so the adapter's own static needs\n  // adding back to the type or callers can't read it.\n  return HlsVideoImpl as unknown as MixinReturn<Base, HlsVideoAdapterAPI> & {\n    readonly alternativeMediaSuggestion: string | undefined;\n    readonly defaultProps: HlsVideoAdapterProps;\n  };\n}\n\n/** Standalone SPF media adapter with no base class. */\nexport class HlsVideoAdapterCore extends HlsVideoMixin(class {}) {}\n"],"mappings":"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"}

package/dist/dev/playback/behaviors/calculate-presentation-duration.d.ts

@@ -0,0 +1,23 @@
+import { MaybeResolvedPresentation } from "../../media/types/index.js";
+import "../../core/signals/primitives.js";
+import "../../core/composition/create-composition.js";
+//#region src/playback/behaviors/calculate-presentation-duration.d.ts
+/**
+ * Input shape passed to the duration resolver. Represents the union of track-selection slots the default
+ * `getResolvedSelectedTrackDuration` resolver inspects to pick a representative resolved track. Variants that compose
+ * neither audio nor video selection still satisfy this shape — the missing fields read as `undefined` and the resolver
+ * falls through.
+ */
+interface PresentationDurationState {
+  presentation?: MaybeResolvedPresentation;
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+}
+/**
+ * Resolver supplied via `config.resolveDuration`. Returns the duration to write to `presentation.duration`, or
+ * `undefined` when it isn't yet derivable. Positive `Infinity` is the canonical live value.
+ */
+type PresentationDurationResolver = (state: PresentationDurationState) => number | undefined;
+//#endregion
+export { PresentationDurationResolver, PresentationDurationState };
+//# sourceMappingURL=calculate-presentation-duration.d.ts.map

package/dist/dev/playback/behaviors/calculate-presentation-duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-presentation-duration.d.ts","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"mappings":";;;;;;;;;;UAmCiB;EACf,eAAe;EACf;EACA;;;;;;KAOU,gCAAgC,OAAO"}

package/dist/dev/playback/behaviors/calculate-presentation-duration.js

@@ -0,0 +1,33 @@
+import { untrack, update } from "../../core/signals/primitives.js";
+import { effect } from "../../core/signals/effect.js";
+//#region src/playback/behaviors/calculate-presentation-duration.ts
+function calculatePresentationDurationSetup({ state, config }) {
+	return effect(() => {
+		const presentation = state.presentation.get();
+		if (!presentation || presentation.duration !== void 0) return;
+		const resolverInput = untrack(() => ({
+			presentation,
+			selectedVideoTrackId: state.selectedVideoTrackId?.get(),
+			selectedAudioTrackId: state.selectedAudioTrackId?.get()
+		}));
+		const duration = config.resolveDuration(resolverInput);
+		if (duration === void 0 || Number.isNaN(duration) || duration <= 0) return;
+		update(state.presentation, { duration });
+	});
+}
+/**
+* `calculatePresentationDuration` uses a manual `Behavior<>` literal (rather than `defineBehavior`) so it can declare
+* just `presentation` in its stateKeys while the typed setup-param shape includes the optional `selectedVideoTrackId` /
+* `selectedAudioTrackId` reads used at runtime. Mirrors the pattern in `endOfStream` for the same reason: the behavior
+* is uniform-across-tracks and reads slots contributed by other behaviors, so it shouldn't leak those slot declarations
+* into variants that don't compose the contributors.
+*/
+const calculatePresentationDuration = {
+	stateKeys: ["presentation"],
+	contextKeys: [],
+	setup: calculatePresentationDurationSetup
+};
+//#endregion
+export { calculatePresentationDuration };
+
+//# sourceMappingURL=calculate-presentation-duration.js.map

package/dist/dev/playback/behaviors/calculate-presentation-duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-presentation-duration.js","names":[],"sources":["../../../../src/playback/behaviors/calculate-presentation-duration.ts"],"sourcesContent":["/**\n * **Populate presentation duration via a config-supplied resolver.**\n *\n * Once a presentation is in place and its `duration` is still undefined, calls `config.resolveDuration(state)` whenever\n * a tracked slot changes. The resolver decides what counts as \"duration is now derivable\" for the variant in play; the\n * behavior itself stays variant-agnostic:\n *\n * - **VoD** — derive from the first resolved selected track's `duration` (video preferred, audio fallback). The HLS\n *   engine wires `getResolvedSelectedTrackDuration` from `media/utils/track-selection.ts` as the default. Audio-only\n *   falls out of the same resolver naturally (no video selected → audio is the first resolved track).\n * - **Live** — return `Number.POSITIVE_INFINITY` once the presentation is established as live. This is the MSE-spec value\n *   for `mediaSource.duration` under live playback; downstream `updateMediaSourceDuration` propagates it through.\n *\n * Validation: writes whatever the resolver returns as long as it's a positive number, including `Infinity`. `undefined`\n * / `NaN` / `<= 0` are skipped.\n *\n * Fires at most once per presentation — an already-set `duration` is never overwritten, and the next reset arrives\n * structurally when a new (unresolved) presentation replaces the current one. The resolver may return `undefined` while\n * duration is still indeterminate; subsequent tracked-slot changes re-run the effect until the resolver commits a\n * value.\n *\n * Downstream of `resolveVideoTrack` / `resolveAudioTrack`; upstream of `updateMediaSourceDuration` (which writes the\n * value through to `mediaSource.duration`).\n */\nimport type { Behavior } from '../../core/composition/create-composition';\nimport { effect } from '../../core/signals/effect';\nimport { type ReadonlySignal, type Signal, untrack, update } from '../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../media/types';\n\n/**\n * Input shape passed to the duration resolver. Represents the union of track-selection slots the default\n * `getResolvedSelectedTrackDuration` resolver inspects to pick a representative resolved track. Variants that compose\n * neither audio nor video selection still satisfy this shape — the missing fields read as `undefined` and the resolver\n * falls through.\n */\nexport interface PresentationDurationState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\n/**\n * Resolver supplied via `config.resolveDuration`. Returns the duration to write to `presentation.duration`, or\n * `undefined` when it isn't yet derivable. Positive `Infinity` is the canonical live value.\n */\nexport type PresentationDurationResolver = (state: PresentationDurationState) => number | undefined;\n\nexport interface PresentationDurationConfig {\n  resolveDuration: PresentationDurationResolver;\n}\n\nfunction calculatePresentationDurationSetup({\n  state,\n  config,\n}: {\n  state: {\n    presentation: Signal<PresentationDurationState['presentation']>;\n    // selectedVideoTrackId / selectedAudioTrackId are read defensively —\n    // they are *not* declared in this behavior's stateKeys. The slots are\n    // contributed by other behaviors (`switchVideoTrack` writes the\n    // video slot in the default engine; `selectAudioTrack` writes the\n    // audio slot) which compose conditionally per engine variant. Treating\n    // each signal as optional lets calculatePresentationDuration stay\n    // variant-agnostic — it feeds whatever's present to the resolver and\n    // lets the resolver decide.\n    selectedVideoTrackId?: ReadonlySignal<PresentationDurationState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<PresentationDurationState['selectedAudioTrackId']>;\n  };\n  config: PresentationDurationConfig;\n}): () => void {\n  return effect(() => {\n    const presentation = state.presentation.get();\n    if (!presentation || presentation.duration !== undefined) return;\n\n    // presentation drives the effect; selection-only changes can't yield a\n    // writable duration on their own (resolver returns undefined until a\n    // track resolves, at which point resolve-track writes back through\n    // state.presentation anyway), so we read the rest untracked.\n    const resolverInput: PresentationDurationState = untrack(() => ({\n      presentation,\n      selectedVideoTrackId: state.selectedVideoTrackId?.get(),\n      selectedAudioTrackId: state.selectedAudioTrackId?.get(),\n    }));\n    const duration = config.resolveDuration(resolverInput);\n    if (duration === undefined || Number.isNaN(duration) || duration <= 0) return;\n\n    // Patch-object form requires `T extends object`; `state.presentation`'s\n    // T is `MaybeResolvedPresentation | undefined`, which doesn't satisfy\n    // the constraint. The guard at the top of the effect already\n    // established that the slot holds a defined value, so cast to narrow\n    // the signal type and use the cleaner merge form.\n    update(state.presentation as Signal<MaybeResolvedPresentation>, { duration });\n  });\n}\n\n/**\n * `calculatePresentationDuration` uses a manual `Behavior<>` literal (rather than `defineBehavior`) so it can declare\n * just `presentation` in its stateKeys while the typed setup-param shape includes the optional `selectedVideoTrackId` /\n * `selectedAudioTrackId` reads used at runtime. Mirrors the pattern in `endOfStream` for the same reason: the behavior\n * is uniform-across-tracks and reads slots contributed by other behaviors, so it shouldn't leak those slot declarations\n * into variants that don't compose the contributors.\n */\nexport const calculatePresentationDuration: Behavior<\n  { presentation: Signal<PresentationDurationState['presentation']> },\n  Record<string, never>,\n  PresentationDurationConfig\n> = {\n  stateKeys: ['presentation'],\n  contextKeys: [],\n  setup: calculatePresentationDurationSetup,\n};\n"],"mappings":";;;AAmDA,SAAS,mCAAmC,EAC1C,OACA,UAgBa;CACb,OAAO,aAAa;EAClB,MAAM,eAAe,MAAM,aAAa,IAAI;EAC5C,IAAI,CAAC,gBAAgB,aAAa,aAAa,KAAA,GAAW;EAM1D,MAAM,gBAA2C,eAAe;GAC9D;GACA,sBAAsB,MAAM,sBAAsB,IAAI;GACtD,sBAAsB,MAAM,sBAAsB,IAAI;EACxD,EAAE;EACF,MAAM,WAAW,OAAO,gBAAgB,aAAa;EACrD,IAAI,aAAa,KAAA,KAAa,OAAO,MAAM,QAAQ,KAAK,YAAY,GAAG;EAOvE,OAAO,MAAM,cAAmD,EAAE,SAAS,CAAC;CAC9E,CAAC;AACH;;;;;;;;AASA,MAAa,gCAIT;CACF,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC;CACd,OAAO;AACT"}

package/dist/dev/playback/behaviors/collect-errors.d.ts

@@ -0,0 +1,2 @@
+import "../../core/signals/primitives.js";
+import "../../index.js";

package/dist/dev/playback/behaviors/collect-errors.js

@@ -0,0 +1,98 @@
+import { computed, peek, update } from "../../core/signals/primitives.js";
+import { defineBehavior } from "../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../core/reactors/create-machine-reactor.js";
+import { isResolvedPresentation } from "../../media/types/index.js";
+//#region src/playback/behaviors/collect-errors.ts
+/**
+* **Owns the engine's error sequence.** Reporters append through {@link emitError}; this behavior owns the slot and its
+* per-source lifecycle, clearing it on exit so a new source starts clean and the sequence can't grow unbounded across a
+* session.
+*
+* Same split as `setupFailoverMonitor` and `failedCdns`: writes come from wherever the condition is detected, one
+* behavior owns the slot. Deliberately has no `effects` — it holds no policy and derives nothing. Severity is decided
+* at the adapter, not here (see `internal/design/spf/features/errors.md`), which is why this is a lifecycle owner
+* rather than an error _handler_.
+*
+* Clearing binds to _exit_ of `presentation-resolved`, mirroring the sibling mixins' clear-on-teardown (`emptied` /
+* `MEDIA_DETACHED`). A live reload swaps the presentation object without leaving the resolved state, so it doesn't
+* clear — only an actual source change or destroy does. Known gap: a resolved→resolved source swap that never passes
+* through unresolved carries the prior source's errors forward; `resolve-track` guards the same transition with a
+* commit-time id check, and doing likewise here is a follow-up.
+*
+* The vocabulary itself ({@link SvtaError} and the codes) is DOM- and signal-free in `media/errors`; only the write
+* seam lives here, with the slot it writes.
+*/
+/**
+* Append `error` to the engine's error sequence. No-op when no owner is composed. Replaces the array rather than
+* mutating it, so signal consumers notify; duplicates are kept, since a repeated condition is a real observation.
+* Writes go through `update` so concurrent reporters can't lose each other's appends.
+*
+* Every emission is logged, deliberately _before_ the owner check. A condition emitted with no `collectErrors` composed
+* is dropped on the floor — that's the case where a log is the only evidence it happened at all, so gating the log on
+* the same check would hide exactly what's worth seeing. Emissions that _are_ collected still get logged, because
+* reaching `state.errors` is no guarantee of reaching a person: only _verdicts_ are promoted to the media surface, so
+* every cause (and any non-fatal notice) is otherwise invisible outside a debugger.
+*
+* Ungated rather than `__DEV__`-only, matching the other reporting paths in this package (`resolve-presentation`,
+* `track-switching`, the segment actors).
+*/
+function emitError(state, error) {
+	console.error("[spf] reported condition", error);
+	if (!state.errors) return;
+	update(state.errors, (errors) => [...errors ?? [], error]);
+}
+/**
+* A "constraint" that reports a type the source carries **no** renditions of, for a composition that can't play without
+* it.
+*
+* Strange on purpose, and the strangeness is the point: it never constrains anything, always returning its input
+* untouched. It is shaped as a rule so a composition opts in by adding it to `constraints` — nothing to thread through
+* config, and no cost at all to a composition that leaves it out.
+*
+* **Belongs last in the chain.** A constraint sees the list as it stands at its own position, so only at the tail does
+* an empty input mean "nothing playable here" — none of this type offered, or the constraints ahead pruned them all.
+*
+* These are the failures no per-rendition cause can report: causes come from `reportUnsupportedTrackConditions` as each
+* media playlist resolves, and a rendition pruned before selection never resolves. Container and encryption aren't
+* knowable until one does; CODECS is, so an undecodable ladder isn't.
+*
+* Idempotent because the constraint chain runs inside a `computed` that re-derives on every `presentation` write —
+* segment appends and live reloads included — and the sequence deliberately keeps duplicates. `peek` is what keeps that
+* computed from subscribing to the slot this writes.
+*
+* @example
+*   // engine-background-video.ts — video-only, so a source with none can't play
+*   constraints: [excludeUnplayableTracks, reportAbsentTrackType(SVTA_NO_SUPPORTED_VIDEO_TRACK)];
+*/
+function reportAbsentTrackType(code) {
+	return (tracks, { state }) => {
+		const reported = state.errors && peek(state.errors);
+		if (!tracks.length && !reported?.some((error) => error.code === code)) emitError(state, { code });
+		return tracks;
+	};
+}
+/**
+* Own `errors` for the resolved source's lifetime.
+*
+* @example
+*   const reactor = collectErrors.setup({ state });
+*/
+const collectErrors = defineBehavior({
+	stateKeys: ["presentation", "errors"],
+	contextKeys: [],
+	setup: ({ state }) => {
+		const derivedStateSignal = computed(() => isResolvedPresentation(state.presentation.get()) ? "presentation-resolved" : "presentation-unresolved");
+		return createMachineReactor({
+			initial: "presentation-unresolved",
+			monitor: () => derivedStateSignal.get(),
+			states: {
+				"presentation-unresolved": {},
+				"presentation-resolved": { entry: () => () => state.errors.set(void 0) }
+			}
+		});
+	}
+});
+//#endregion
+export { collectErrors, emitError, reportAbsentTrackType };
+
+//# sourceMappingURL=collect-errors.js.map