@videojs/spf 10.0.0-beta.26 → 10.0.0-beta.28

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

@@ -0,0 +1,126 @@
+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 HlsVideoMediaMediaTracksMixin(BaseClass) {
+	class HlsVideoMediaMediaTracks 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 HlsVideoMediaMediaTracks;
+}
+//#endregion
+export { HlsVideoMediaMediaTracksMixin };
+
+//# sourceMappingURL=media-tracks.js.map

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';\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\n * `videoRenditions` / `audioTracks` lists, and wires user selection back to the\n * engine's `userVideoTrackSelection` / `userAudioTrackSelection` signals.\n *\n * Requires the media-tracks mixin (track-list infrastructure) earlier in the\n * chain so the host exposes `addVideoTrack`, `videoRenditions`, and friends.\n */\nexport function HlsVideoMediaMediaTracksMixin<Base extends Constructor<MediaTracksHost>>(BaseClass: Base) {\n  class HlsVideoMediaMediaTracks 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        this.#renditions = renditions;\n        this.#removeVideoTracks();\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        videoTrack.selected = true;\n\n        const resolved = untrack(() => findVideoTrackById(state.presentation.get(), state.selectedVideoTrackId.get()));\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          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        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        this.#audioTracks = tracks;\n        this.#removeAudioTracks();\n        if (!tracks.length) return;\n\n        const resolved = untrack(() => findAudioTrackById(state.presentation.get(), state.selectedAudioTrackId.get()));\n        for (const track of tracks) {\n          const domTrack = this.addAudioTrack(track.default ? 'main' : 'alternative', track.name, track.language ?? '');\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        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      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      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      // 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      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 HlsVideoMediaMediaTracks as unknown as Base;\n}\n"],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","names":[],"sources":["../../../../../src/playback/adapters/hls-video/media.ts"],"mappings":";;;cAKM,yDAAiB,+CAAA,YAAA,uBAAA,2BAAA,YAAA;;;cAEV,sBAAsB"}

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

@@ -0,0 +1,11 @@
+import { HlsVideoMediaMixin } from "./adapter.js";
+import { HlsVideoMediaMediaTracksMixin } from "./media-tracks.js";
+import { HTMLVideoElementHost } from "@videojs/media/dom/video-host";
+import { MediaTracksMixin } from "@videojs/media/media-tracks";
+//#region src/playback/adapters/hls-video/media.ts
+const HlsVideoMediaBase = HlsVideoMediaMediaTracksMixin(MediaTracksMixin(HlsVideoMediaMixin(HTMLVideoElementHost)));
+var HlsVideoMedia = class extends HlsVideoMediaBase {};
+//#endregion
+export { HlsVideoMedia };
+
+//# sourceMappingURL=media.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.js","names":[],"sources":["../../../../../src/playback/adapters/hls-video/media.ts"],"sourcesContent":["import { HTMLVideoElementHost } from '@videojs/media/dom/video-host';\nimport { MediaTracksMixin } from '@videojs/media/media-tracks';\nimport { HlsVideoMediaMixin } from './adapter';\nimport { HlsVideoMediaMediaTracksMixin } from './media-tracks';\n\nconst HlsVideoMediaBase = HlsVideoMediaMediaTracksMixin(MediaTracksMixin(HlsVideoMediaMixin(HTMLVideoElementHost)));\n\nexport class HlsVideoMedia extends HlsVideoMediaBase {}\n"],"mappings":";;;;;AAKA,MAAM,oBAAoB,8BAA8B,iBAAiB,mBAAmB,oBAAoB,CAAC,CAAC;AAElH,IAAa,gBAAb,cAAmC,kBAAkB,CAAC"}

package/dist/dev/playback/adapters/mux-audio/media.d.ts

@@ -0,0 +1,28 @@
+import { HlsAudioMedia } from "../hls-audio/media.js";
+import { MuxMediaAPI } from "../mux-video/adapter.js";
+import "../../../mux-audio.js";
+//#region src/playback/adapters/mux-audio/media.d.ts
+declare const MuxAudioMediaBase: import("@videojs/utils/types").Constructor<HlsAudioMedia & MuxMediaAPI, any[]> & Omit<typeof HlsAudioMedia, "prototype"> & {
+  readonly alternativeMediaSuggestion: string | undefined;
+};
+/**
+ * The Mux Media over the SPF audio-only HLS engine.
+ *
+ * Same Mux surface as the video flavor — `src`, the structured `source`, and the
+ * derived `contentData` all come from the shared mixin — over the subtractive
+ * engine, so only the audio renditions of whatever the playback ID names are
+ * fetched. That is the one place this diverges from the hls.js-backed
+ * `<mux-audio>`, which runs the full engine and downloads video renditions it
+ * never shows.
+ *
+ * `contentData` is kept rather than dropped, for the same reason its hls.js
+ * counterpart has it: a playback ID played as audio is usually a *video* asset,
+ * whose poster and storyboard exist and which an audio skin may well want. The
+ * element ignores it either way. Mux publishes neither for a genuinely
+ * audio-only asset, so those URLs 404 — see the known shortcoming on the video
+ * flavor, which shares the derivation.
+ */
+declare class MuxAudioMedia extends MuxAudioMediaBase {}
+//#endregion
+export { MuxAudioMedia };
+//# sourceMappingURL=media.d.ts.map

package/dist/dev/playback/adapters/mux-audio/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","names":[],"sources":["../../../../../src/playback/adapters/mux-audio/media.ts"],"mappings":";;;;cASM,kDAAiB,YAAA,gBAAA,sBAAA,YAAA;;;;;;;;;;;;;;;;;;;;cAmBV,sBAAsB"}

package/dist/dev/playback/adapters/mux-audio/media.js

@@ -0,0 +1,26 @@
+import { HlsAudioMedia } from "../hls-audio/media.js";
+import { MuxMediaMixin } from "../mux-video/adapter.js";
+//#region src/playback/adapters/mux-audio/media.ts
+const MuxAudioMediaBase = MuxMediaMixin(HlsAudioMedia);
+/**
+* The Mux Media over the SPF audio-only HLS engine.
+*
+* Same Mux surface as the video flavor — `src`, the structured `source`, and the
+* derived `contentData` all come from the shared mixin — over the subtractive
+* engine, so only the audio renditions of whatever the playback ID names are
+* fetched. That is the one place this diverges from the hls.js-backed
+* `<mux-audio>`, which runs the full engine and downloads video renditions it
+* never shows.
+*
+* `contentData` is kept rather than dropped, for the same reason its hls.js
+* counterpart has it: a playback ID played as audio is usually a *video* asset,
+* whose poster and storyboard exist and which an audio skin may well want. The
+* element ignores it either way. Mux publishes neither for a genuinely
+* audio-only asset, so those URLs 404 — see the known shortcoming on the video
+* flavor, which shares the derivation.
+*/
+var MuxAudioMedia = class extends MuxAudioMediaBase {};
+//#endregion
+export { MuxAudioMedia };
+
+//# sourceMappingURL=media.js.map

package/dist/dev/playback/adapters/mux-audio/media.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.js","names":[],"sources":["../../../../../src/playback/adapters/mux-audio/media.ts"],"sourcesContent":["// Deliberately the mixin's own module, not `../mux-video`: that barrel reaches\n// `MuxVideoMedia`, and through it `HlsVideoMedia` and the full HLS engine. The\n// mixin alone carries no engine, which is what keeps this entry point\n// audio-only. Same shape as `hls-audio` importing its error surface\n// from `../hls-video`.\n\nimport { HlsAudioMedia } from '../hls-audio/media';\nimport { MuxMediaMixin } from '../mux-video/adapter';\n\nconst MuxAudioMediaBase = MuxMediaMixin(HlsAudioMedia);\n\n/**\n * The Mux Media over the SPF audio-only HLS engine.\n *\n * Same Mux surface as the video flavor — `src`, the structured `source`, and the\n * derived `contentData` all come from the shared mixin — over the subtractive\n * engine, so only the audio renditions of whatever the playback ID names are\n * fetched. That is the one place this diverges from the hls.js-backed\n * `<mux-audio>`, which runs the full engine and downloads video renditions it\n * never shows.\n *\n * `contentData` is kept rather than dropped, for the same reason its hls.js\n * counterpart has it: a playback ID played as audio is usually a *video* asset,\n * whose poster and storyboard exist and which an audio skin may well want. The\n * element ignores it either way. Mux publishes neither for a genuinely\n * audio-only asset, so those URLs 404 — see the known shortcoming on the video\n * flavor, which shares the derivation.\n */\nexport class MuxAudioMedia extends MuxAudioMediaBase {}\n"],"mappings":";;;AASA,MAAM,oBAAoB,cAAc,aAAa;;;;;;;;;;;;;;;;;;AAmBrD,IAAa,gBAAb,cAAmC,kBAAkB,CAAC"}

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

@@ -0,0 +1,33 @@
+import { MuxContentData, MuxSourceBase } from "@videojs/media/dom/mux/source";
+import { Constructor, MixinReturn } from "@videojs/utils/types";
+//#region src/playback/adapters/mux-video/adapter.d.ts
+interface MuxMediaProps {
+  src: string;
+  source: MuxSourceBase | null;
+}
+declare const muxMediaDefaultProps: MuxMediaProps;
+interface MuxMediaAPI extends MuxMediaProps {
+  readonly contentData: MuxContentData;
+}
+/**
+ * Mux identity over any SPF Media: the structured `source`, the `src` derived
+ * from it, and the image URLs it describes.
+ *
+ * Everything here is Mux identity, so it carries no engine and both flavors get
+ * it unchanged — the video Media over the full HLS engine, the audio-only Media
+ * over the subtractive one. A mixin rather than a shared base class because each
+ * flavor extends a different SPF Media, so there is no common class to put this
+ * on, only a common `src` accessor to write through.
+ *
+ * Unlike the hls.js-backed `MuxMedia`, there is no inherited `source` to
+ * delegate to — the SPF Medias know only `src` — so this owns the structured
+ * source and dispatches `sourcechange` itself.
+ *
+ * @fires sourcechange - Fired when `source` changes, either directly or by parsing a new `src`. Read `source` for the new value.
+ */
+declare function MuxMediaMixin<Base extends Constructor<any>>(BaseClass: Base): MixinReturn<Base, MuxMediaAPI> & {
+  readonly alternativeMediaSuggestion: string | undefined;
+};
+//#endregion
+export { MuxMediaAPI, MuxMediaMixin, MuxMediaProps, muxMediaDefaultProps };
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","names":[],"sources":["../../../../../src/playback/adapters/mux-video/adapter.ts"],"mappings":";;;UAUiB;EACf;EACA,QAAQ;;cAGG,sBAAsB;UAKlB,oBAAoB;WAC1B,aAAa;;;;;;;;;;;;;;;;;;iBAmBR,cAAc,aAAa,kBAAkB,WAAW,OAkFpC,YAAY,MAAM;WACzC"}

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

@@ -0,0 +1,92 @@
+import { createMuxPosterURL, createMuxStoryboardURL, createMuxVideoURL, parseMuxVideoURL } from "@videojs/media/dom/mux/source";
+//#region src/playback/adapters/mux-video/adapter.ts
+const muxMediaDefaultProps = {
+	src: "",
+	source: null
+};
+/**
+* Mux identity over any SPF Media: the structured `source`, the `src` derived
+* from it, and the image URLs it describes.
+*
+* Everything here is Mux identity, so it carries no engine and both flavors get
+* it unchanged — the video Media over the full HLS engine, the audio-only Media
+* over the subtractive one. A mixin rather than a shared base class because each
+* flavor extends a different SPF Media, so there is no common class to put this
+* on, only a common `src` accessor to write through.
+*
+* Unlike the hls.js-backed `MuxMedia`, there is no inherited `source` to
+* delegate to — the SPF Medias know only `src` — so this owns the structured
+* source and dispatches `sourcechange` itself.
+*
+* @fires sourcechange - Fired when `source` changes, either directly or by parsing a new `src`. Read `source` for the new value.
+*/
+function MuxMediaMixin(BaseClass) {
+	class MuxMediaImpl extends BaseClass {
+		/**
+		* Named on the error copy when this engine can't play a source: the
+		* hls.js-backed Mux Media plays the MPEG-TS and DRM-protected sources that
+		* SPF does not, and it backs both `<mux-video>` and `<mux-audio>`.
+		*
+		* Names the flavor rather than an import path, because one Media is reached
+		* through three of them — `@videojs/html`, `@videojs/react`, and this package
+		* — and each has a different counterpart. The flavor suffix is the one thing
+		* common to the layers a consumer imports elements and components from.
+		*/
+		static get alternativeMediaSuggestion() {
+			return "Try the hls.js-backed Mux media instead: import the `hls-js` flavor in place of the `spf` one.";
+		}
+		#source = muxMediaDefaultProps.source;
+		/**
+		* Media source URL. Setting a Mux stream URL
+		* (`https://stream.mux.com/<playback-id>.m3u8?...`) extracts the playback ID
+		* and query params into `source`; other URLs are kept as a plain `source.src`.
+		*
+		* Only playback options carry over. Mux identity comes from the URL, and the
+		* signed `poster`, `storyboard`, and `drm` tokens are scoped to a playback ID,
+		* so carrying them onto a different source would build rejected URLs.
+		*/
+		get src() {
+			return super.src;
+		}
+		set src(value) {
+			if (super.src === value) return;
+			this.source = parseMuxVideoURL(value) ?? (value ? { src: value } : null);
+		}
+		/**
+		* Structured Mux source. Setting it derives `src` from the playback ID, custom
+		* domain, and `playback` params (appended as `snake_case` query params). A
+		* `playback.token` replaces all other params — signed URLs bake them into the
+		* token.
+		*/
+		get source() {
+			return this.#source;
+		}
+		set source(value) {
+			const source = value ?? null;
+			if (source === this.#source) return;
+			this.#source = source;
+			super.src = source && (createMuxVideoURL(source) ?? source.src) || "";
+			this.dispatchEvent?.(new Event("sourcechange"));
+		}
+		/**
+		* Image URLs `source` describes rather than plays: `poster` from its `poster`
+		* params, `storyboard` from its `storyboard` params.
+		*
+		* Read-only and re-derived on read, so read it again after `sourcechange`.
+		* Nothing here is applied for you.
+		*/
+		get contentData() {
+			const poster = createMuxPosterURL(this.#source);
+			const storyboard = createMuxStoryboardURL(this.#source);
+			return {
+				...poster && { poster },
+				...storyboard && { storyboard }
+			};
+		}
+	}
+	return MuxMediaImpl;
+}
+//#endregion
+export { MuxMediaMixin, muxMediaDefaultProps };
+
+//# sourceMappingURL=adapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","names":["#source"],"sources":["../../../../../src/playback/adapters/mux-video/adapter.ts"],"sourcesContent":["import {\n  createMuxPosterURL,\n  createMuxStoryboardURL,\n  createMuxVideoURL,\n  type MuxContentData,\n  type MuxSourceBase,\n  parseMuxVideoURL,\n} from '@videojs/media/dom/mux/source';\nimport type { Constructor, MixinReturn } from '@videojs/utils/types';\n\nexport interface MuxMediaProps {\n  src: string;\n  source: MuxSourceBase | null;\n}\n\nexport const muxMediaDefaultProps: MuxMediaProps = {\n  src: '',\n  source: null,\n};\n\nexport interface MuxMediaAPI extends MuxMediaProps {\n  readonly contentData: MuxContentData;\n}\n\n/**\n * Mux identity over any SPF Media: the structured `source`, the `src` derived\n * from it, and the image URLs it describes.\n *\n * Everything here is Mux identity, so it carries no engine and both flavors get\n * it unchanged — the video Media over the full HLS engine, the audio-only Media\n * over the subtractive one. A mixin rather than a shared base class because each\n * flavor extends a different SPF Media, so there is no common class to put this\n * on, only a common `src` accessor to write through.\n *\n * Unlike the hls.js-backed `MuxMedia`, there is no inherited `source` to\n * delegate to — the SPF Medias know only `src` — so this owns the structured\n * source and dispatches `sourcechange` itself.\n *\n * @fires sourcechange - Fired when `source` changes, either directly or by parsing a new `src`. Read `source` for the new value.\n */\nexport function MuxMediaMixin<Base extends Constructor<any>>(BaseClass: Base) {\n  class MuxMediaImpl extends BaseClass {\n    /**\n     * Named on the error copy when this engine can't play a source: the\n     * hls.js-backed Mux Media plays the MPEG-TS and DRM-protected sources that\n     * SPF does not, and it backs both `<mux-video>` and `<mux-audio>`.\n     *\n     * Names the flavor rather than an import path, because one Media is reached\n     * through three of them — `@videojs/html`, `@videojs/react`, and this package\n     * — and each has a different counterpart. The flavor suffix is the one thing\n     * common to the layers a consumer imports elements and components from.\n     */\n    static get alternativeMediaSuggestion(): string | undefined {\n      return 'Try the hls.js-backed Mux media instead: import the `hls-js` flavor in place of the `spf` one.';\n    }\n\n    #source: MuxSourceBase | null = muxMediaDefaultProps.source;\n\n    /**\n     * Media source URL. Setting a Mux stream URL\n     * (`https://stream.mux.com/<playback-id>.m3u8?...`) extracts the playback ID\n     * and query params into `source`; other URLs are kept as a plain `source.src`.\n     *\n     * Only playback options carry over. Mux identity comes from the URL, and the\n     * signed `poster`, `storyboard`, and `drm` tokens are scoped to a playback ID,\n     * so carrying them onto a different source would build rejected URLs.\n     */\n    get src(): string {\n      return super.src;\n    }\n\n    set src(value: string) {\n      // A URL already describing the current source leaves it alone. The elements\n      // reflect the derived `src` back to the host, and re-deriving would drop the\n      // params a Mux URL does not carry, such as `poster`.\n      if (super.src === value) return;\n\n      this.source = parseMuxVideoURL(value) ?? (value ? { src: value } : null);\n    }\n\n    /**\n     * Structured Mux source. Setting it derives `src` from the playback ID, custom\n     * domain, and `playback` params (appended as `snake_case` query params). A\n     * `playback.token` replaces all other params — signed URLs bake them into the\n     * token.\n     */\n    get source(): MuxSourceBase | null {\n      return this.#source;\n    }\n\n    set source(value: MuxSourceBase | null) {\n      const source = value ?? null;\n      // Changing anything takes a new object, so handing the same one back costs\n      // nothing.\n      if (source === this.#source) return;\n\n      this.#source = source;\n      super.src = (source && (createMuxVideoURL(source) ?? source.src)) || '';\n\n      this.dispatchEvent?.(new Event('sourcechange'));\n    }\n\n    /**\n     * Image URLs `source` describes rather than plays: `poster` from its `poster`\n     * params, `storyboard` from its `storyboard` params.\n     *\n     * Read-only and re-derived on read, so read it again after `sourcechange`.\n     * Nothing here is applied for you.\n     */\n    get contentData(): MuxContentData {\n      const poster = createMuxPosterURL(this.#source);\n      const storyboard = createMuxStoryboardURL(this.#source);\n\n      return {\n        ...(poster && { poster }),\n        ...(storyboard && { storyboard }),\n      };\n    }\n  }\n\n  // `MixinReturn` sources statics from `Base`, so this mixin's own needs adding\n  // back to the type or callers can't read it.\n  return MuxMediaImpl as unknown as MixinReturn<Base, MuxMediaAPI> & {\n    readonly alternativeMediaSuggestion: string | undefined;\n  };\n}\n"],"mappings":";;AAeA,MAAa,uBAAsC;CACjD,KAAK;CACL,QAAQ;AACV;;;;;;;;;;;;;;;;;AAsBA,SAAgB,cAA6C,WAAiB;CAC5E,MAAM,qBAAqB,UAAU;;;;;;;;;;;EAWnC,WAAW,6BAAiD;GAC1D,OAAO;EACT;EAEA,UAAgC,qBAAqB;;;;;;;;;;EAWrD,IAAI,MAAc;GAChB,OAAO,MAAM;EACf;EAEA,IAAI,IAAI,OAAe;GAIrB,IAAI,MAAM,QAAQ,OAAO;GAEzB,KAAK,SAAS,iBAAiB,KAAK,MAAM,QAAQ,EAAE,KAAK,MAAM,IAAI;EACrE;;;;;;;EAQA,IAAI,SAA+B;GACjC,OAAO,KAAKA;EACd;EAEA,IAAI,OAAO,OAA6B;GACtC,MAAM,SAAS,SAAS;GAGxB,IAAI,WAAW,KAAKA,SAAS;GAE7B,KAAKA,UAAU;GACf,MAAM,MAAO,WAAW,kBAAkB,MAAM,KAAK,OAAO,QAAS;GAErE,KAAK,gBAAgB,IAAI,MAAM,cAAc,CAAC;EAChD;;;;;;;;EASA,IAAI,cAA8B;GAChC,MAAM,SAAS,mBAAmB,KAAKA,OAAO;GAC9C,MAAM,aAAa,uBAAuB,KAAKA,OAAO;GAEtD,OAAO;IACL,GAAI,UAAU,EAAE,OAAO;IACvB,GAAI,cAAc,EAAE,WAAW;GACjC;EACF;CACF;CAIA,OAAO;AAGT"}

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

@@ -0,0 +1,24 @@
+import { HlsVideoMedia } from "../hls-video/media.js";
+import { MuxMediaAPI } from "./adapter.js";
+//#region src/playback/adapters/mux-video/media.d.ts
+declare const MuxVideoMediaBase: import("@videojs/utils/types").Constructor<HlsVideoMedia & MuxMediaAPI, any[]> & Omit<typeof HlsVideoMedia, "prototype"> & {
+  readonly alternativeMediaSuggestion: string | undefined;
+};
+/**
+ * The Mux Media over the SPF HLS engine.
+ *
+ * Mirrors `@videojs/media/dom/mux`'s hls.js-backed `MuxMedia` — same class shape,
+ * same `src`/`source` relationship, same derived `contentData` — over a different
+ * engine, though named for the flavor rather than sharing that class's name. It
+ * carries no `engine` or `preferPlayback`: SPF publishes no
+ * engine-shaped config for a consumer to pass, so the source is Mux identity and
+ * nothing else.
+ *
+ * `source.drm` is accepted but inert. SPF prunes encrypted renditions and reports
+ * unsupported DRM, and `alternativeMediaSuggestion` points at the hls.js-backed
+ * import, so a protected source fails with copy that says where to go.
+ */
+declare class MuxVideoMedia extends MuxVideoMediaBase {}
+//#endregion
+export { MuxVideoMedia };
+//# sourceMappingURL=media.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","names":[],"sources":["../../../../../src/playback/adapters/mux-video/media.ts"],"mappings":";;;cAGM,kDAAiB,YAAA,gBAAA,sBAAA,YAAA;;;;;;;;;;;;;;;;;cAgBV,sBAAsB"}

package/dist/dev/playback/adapters/mux-video/media.js

@@ -0,0 +1,23 @@
+import { HlsVideoMedia } from "../hls-video/media.js";
+import { MuxMediaMixin } from "./adapter.js";
+//#region src/playback/adapters/mux-video/media.ts
+const MuxVideoMediaBase = MuxMediaMixin(HlsVideoMedia);
+/**
+* The Mux Media over the SPF HLS engine.
+*
+* Mirrors `@videojs/media/dom/mux`'s hls.js-backed `MuxMedia` — same class shape,
+* same `src`/`source` relationship, same derived `contentData` — over a different
+* engine, though named for the flavor rather than sharing that class's name. It
+* carries no `engine` or `preferPlayback`: SPF publishes no
+* engine-shaped config for a consumer to pass, so the source is Mux identity and
+* nothing else.
+*
+* `source.drm` is accepted but inert. SPF prunes encrypted renditions and reports
+* unsupported DRM, and `alternativeMediaSuggestion` points at the hls.js-backed
+* import, so a protected source fails with copy that says where to go.
+*/
+var MuxVideoMedia = class extends MuxVideoMediaBase {};
+//#endregion
+export { MuxVideoMedia };
+
+//# sourceMappingURL=media.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.js","names":[],"sources":["../../../../../src/playback/adapters/mux-video/media.ts"],"sourcesContent":["import { HlsVideoMedia } from '../hls-video/media';\nimport { MuxMediaMixin } from './adapter';\n\nconst MuxVideoMediaBase = MuxMediaMixin(HlsVideoMedia);\n\n/**\n * The Mux Media over the SPF HLS engine.\n *\n * Mirrors `@videojs/media/dom/mux`'s hls.js-backed `MuxMedia` — same class shape,\n * same `src`/`source` relationship, same derived `contentData` — over a different\n * engine, though named for the flavor rather than sharing that class's name. It\n * carries no `engine` or `preferPlayback`: SPF publishes no\n * engine-shaped config for a consumer to pass, so the source is Mux identity and\n * nothing else.\n *\n * `source.drm` is accepted but inert. SPF prunes encrypted renditions and reports\n * unsupported DRM, and `alternativeMediaSuggestion` points at the hls.js-backed\n * import, so a protected source fails with copy that says where to go.\n */\nexport class MuxVideoMedia extends MuxVideoMediaBase {}\n"],"mappings":";;;AAGA,MAAM,oBAAoB,cAAc,aAAa;;;;;;;;;;;;;;;AAgBrD,IAAa,gBAAb,cAAmC,kBAAkB,CAAC"}

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

@@ -0,0 +1,77 @@
+import { computed, 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]);
+}
+/**
+* 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 };
+
+//# sourceMappingURL=collect-errors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collect-errors.js","names":[],"sources":["../../../../src/playback/behaviors/collect-errors.ts"],"sourcesContent":["/**\n * **Owns the engine's error sequence.** Reporters append through\n * {@link emitError}; this behavior owns the slot and its per-source lifecycle,\n * clearing it on exit so a new source starts clean and the sequence can't grow\n * unbounded across a session.\n *\n * Same split as `setupFailoverMonitor` and `failedCdns`: writes come from\n * wherever the condition is detected, one behavior owns the slot. Deliberately\n * has no `effects` — it holds no policy and derives nothing. Severity is decided\n * at the adapter, not here (see `internal/design/spf/features/errors.md`), which\n * is why this is a lifecycle owner rather than an error *handler*.\n *\n * Clearing binds to *exit* of `presentation-resolved`, mirroring the sibling\n * mixins' clear-on-teardown (`emptied` / `MEDIA_DETACHED`). A live reload swaps\n * the presentation object without leaving the resolved state, so it doesn't\n * clear — only an actual source change or destroy does. Known gap: a\n * resolved→resolved source swap that never passes through unresolved carries the\n * prior source's errors forward; `resolve-track` guards the same transition with\n * a commit-time id check, and doing likewise here is a follow-up.\n *\n * The vocabulary itself ({@link SvtaError} and the codes) is DOM- and\n * signal-free in `media/errors`; only the write seam lives here, with the slot\n * it writes.\n */\n\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal, update } from '../../core/signals/primitives';\nimport type { SvtaError } from '../../media/errors';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';\n\nexport interface CollectErrorsState {\n  presentation?: MaybeResolvedPresentation;\n  errors?: SvtaError[];\n}\n\n/**\n * State an error reporter writes into. The slot is *optional*: a behavior reports\n * through this seam without declaring ownership in its own typed slice, and\n * emission no-ops when `collectErrors` isn't composed. Same contract as\n * `failedCdns` / `failoverFetch`.\n */\nexport interface ErrorEmitterState {\n  errors?: Signal<SvtaError[] | undefined>;\n}\n\n/**\n * Append `error` to the engine's error sequence. No-op when no owner is\n * composed. Replaces the array rather than mutating it, so signal consumers\n * notify; duplicates are kept, since a repeated condition is a real observation.\n * Writes go through `update` so concurrent reporters can't lose each other's\n * appends.\n *\n * Every emission is logged, deliberately *before* the owner check. A condition\n * emitted with no `collectErrors` composed is dropped on the floor — that's the\n * case where a log is the only evidence it happened at all, so gating the log on\n * the same check would hide exactly what's worth seeing. Emissions that *are*\n * collected still get logged, because reaching `state.errors` is no guarantee of\n * reaching a person: only *verdicts* are promoted to the media surface, so every\n * cause (and any non-fatal notice) is otherwise invisible outside a debugger.\n *\n * Ungated rather than `__DEV__`-only, matching the other reporting paths in this\n * package (`resolve-presentation`, `track-switching`, the segment actors).\n */\nexport function emitError(state: ErrorEmitterState, error: SvtaError): void {\n  console.error('[spf] reported condition', error);\n  if (!state.errors) return;\n  update(state.errors, (errors) => [...(errors ?? []), error]);\n}\n\n/**\n * Own `errors` for the resolved source's lifetime.\n *\n * @example\n * const reactor = collectErrors.setup({ state });\n */\nexport const collectErrors = defineBehavior({\n  stateKeys: ['presentation', 'errors'],\n  contextKeys: [],\n  setup: ({\n    state,\n  }: {\n    state: {\n      presentation: ReadonlySignal<CollectErrorsState['presentation']>;\n      errors: Signal<CollectErrorsState['errors']>;\n    };\n  }) => {\n    const derivedStateSignal = computed(() =>\n      isResolvedPresentation(state.presentation.get())\n        ? ('presentation-resolved' as const)\n        : ('presentation-unresolved' as const)\n    );\n\n    return createMachineReactor({\n      initial: 'presentation-unresolved',\n      monitor: () => derivedStateSignal.get(),\n      states: {\n        'presentation-unresolved': {},\n        'presentation-resolved': {\n          // Cleanup-binds-to-setup: reset for the next source on exit (src\n          // unload + destroy).\n          entry: () => () => state.errors.set(undefined),\n        },\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,SAAgB,UAAU,OAA0B,OAAwB;CAC1E,QAAQ,MAAM,4BAA4B,KAAK;CAC/C,IAAI,CAAC,MAAM,QAAQ;CACnB,OAAO,MAAM,SAAS,WAAW,CAAC,GAAI,UAAU,CAAC,GAAI,KAAK,CAAC;AAC7D;;;;;;;AAQA,MAAa,gBAAgB,eAAe;CAC1C,WAAW,CAAC,gBAAgB,QAAQ;CACpC,aAAa,CAAC;CACd,QAAQ,EACN,YAMI;EACJ,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,IAAI,CAAC,IAC1C,0BACA,yBACP;EAEA,OAAO,qBAAqB;GAC1B,SAAS;GACT,eAAe,mBAAmB,IAAI;GACtC,QAAQ;IACN,2BAA2B,CAAC;IAC5B,yBAAyB,EAGvB,mBAAmB,MAAM,OAAO,IAAI,KAAA,CAAS,EAC/C;GACF;EACF,CAAC;CACH;AACF,CAAC"}

package/dist/dev/playback/behaviors/dom/end-of-stream.js

@@ -30,6 +30,7 @@ function deriveState(presentation, mediaSource, msIsOpen, videoBufferActor, audi
 		if (!initTrackId) return "preconditions-unmet";
 		const track = findTrackById(presentation, initTrackId);
 		if (!track || !isResolvedTrack(track)) return "preconditions-unmet";
+		if (!Number.isFinite(track.duration)) return "preconditions-unmet";
 		if (!isLastSegmentAppended(track.segments, appended)) return "preconditions-unmet";
 		if (track.segments.length > 0) {
 			const start = track.segments[track.segments.length - 1].startTime;