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

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

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

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

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

package/dist/default/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/default/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":";;;;AA2BA,MAAM,cAAc,eAAmC;CACrD,OAAO,UAAU;CACjB,QAAQ,UAAU;CAClB,WAAW,UAAU;AACvB;AAEA,MAAM,cAAc,WAA2B;CAAE,UAAU,MAAM;CAAU,MAAM,MAAM;AAAM;;AAa7F,MAAM,WAAW,GAAqB,MACpC,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,MAAM,MAAM,KAAK,OAAO,EAAE,EAAE,CAAE,EAAE;;;;;;;;;AAUpE,SAAgB,8BAAyE,WAAiB;CACxG,MAAM,iCAAkC,UAA2C;EACjF,SAAS,IAAI,gBAAgB;EAC7B,aAAa;EAIb,cAA4B,CAAC;EAC7B,eAA6B,CAAC;EAE9B,YAAY,GAAG,MAAa;GAC1B,MAAM,GAAG,IAAI;GAEb,MAAM,EAAE,UAAU,KAAK;GACvB,MAAM,EAAE,WAAW,KAAKA;GAExB,MAAM,mBAAmB,eAAe,mBAAmB,MAAM,aAAa,IAAI,CAAC,GAAG,EAAE,QAAQ,QAAQ,CAAC;GACzG,MAAM,oBAAoB,eAAe,mBAAmB,MAAM,aAAa,IAAI,CAAC,GAAG,EAAE,QAAQ,QAAQ,CAAC;GAK1G,MAAM,0BAA0B;IAC9B,MAAM,aAAa,iBAAiB,IAAI;IACxC,KAAKC,cAAc;IACnB,KAAKC,mBAAmB;IACxB,IAAI,CAAC,WAAW,QAAQ;IAYxB,MAAM,aAAa,KAAK,cAAc,MAAM;IAC5C,WAAW,WAAW;IAEtB,MAAM,WAAW,cAAc,mBAAmB,MAAM,aAAa,IAAI,GAAG,MAAM,qBAAqB,IAAI,CAAC,CAAC;IAC7G,KAAK,MAAM,aAAa,YAAY;KAClC,MAAM,eAAe,WAAW,aAC9B,IACA,UAAU,OACV,UAAU,QACV,UAAU,OAAO,KAAK,GAAG,GACzB,UAAU,WACV,UAAU,YAAY,kBAAkB,UAAU,SAAS,IAAI,KAAA,CACjE;KACA,aAAa,KAAK,UAAU;KAC5B,aAAa,SAAS,iBAAiB,WAAW,YAAY,GAAG,QAAQ;IAC3E;GACF;GAEA,MAAM,6BAA6B;IACjC,MAAM,WAAW,mBAAmB,MAAM,aAAa,IAAI,GAAG,MAAM,qBAAqB,IAAI,CAAC;IAC9F,KAAK,MAAM,aAAa,KAAK,iBAC3B,UAAU,SAAS,iBAAiB,WAAW,SAAS,GAAG,QAAQ;GAEvE;GAIA,MAAM,2BAA2B;IAC/B,MAAM,SAAS,kBAAkB,IAAI;IACrC,KAAKC,eAAe;IACpB,KAAKC,mBAAmB;IACxB,IAAI,CAAC,OAAO,QAAQ;IAEpB,MAAM,WAAW,cAAc,mBAAmB,MAAM,aAAa,IAAI,GAAG,MAAM,qBAAqB,IAAI,CAAC,CAAC;IAC7G,KAAK,MAAM,SAAS,QAAQ;KAC1B,MAAM,WAAW,KAAK,cAAc,MAAM,UAAU,SAAS,eAAe,MAAM,MAAM,MAAM,YAAY,EAAE;KAC5G,SAAS,KAAK,MAAM;KACpB,SAAS,UAAU,iBAAiB,WAAW,QAAQ,GAAG,QAAQ;IACpE;GACF;GAEA,MAAM,6BAA6B;IACjC,MAAM,WAAW,mBAAmB,MAAM,aAAa,IAAI,GAAG,MAAM,qBAAqB,IAAI,CAAC;IAC9F,KAAK,MAAM,SAAS,KAAK,aACvB,MAAM,UAAU,iBAAiB,WAAW,KAAK,GAAG,QAAQ;GAEhE;GAMA,MAAM,YAAY,eAAe,MAAM,aAAa,IAAI,CAAC,EAAE,GAAG;GAC9D,MAAM,qCAAqC;IACzC,UAAU,IAAI;IACd,MAAM,wBAAwB,IAAI,KAAA,CAAS;IAC3C,MAAM,wBAAwB,IAAI,KAAA,CAAS;GAC7C;GAEA,MAAM,iBAAiB;IACrB,OAAO,iBAAiB;IACxB,OAAO,oBAAoB;IAC3B,OAAO,kBAAkB;IACzB,OAAO,oBAAoB;IAC3B,OAAO,4BAA4B;GACrC;GAEA,KAAK,gBAAgB,iBAAiB,UAAU,KAAKC,kBAAkB,EAAE,OAAO,CAAC;GACjF,KAAK,YAAY,iBAAiB,UAAU,KAAKC,cAAc,EAAE,OAAO,CAAC;GACzE,OAAO,iBAAiB,eAAe,eAAe,SAAS,YAAY,QAAQ,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC;EACvG;EAEA,UAAgB;GACd,IAAI,KAAKC,YAAY;GACrB,KAAKA,aAAa;GAClB,KAAKP,OAAO,MAAM;GAClB,KAAKE,mBAAmB;GACxB,KAAKE,mBAAmB;GACxB,MAAM,UAAU;EAClB;EAKA,yBAAyB;GACvB,MAAM,EAAE,4BAA4B,KAAK,OAAO;GAChD,MAAM,QAAQ,KAAK,gBAAgB;GACnC,MAAM,eAAe,QAAQ,IAAI,KAAA,IAAY,KAAK,gBAAgB;GAClE,MAAM,YAAY,KAAKH,YAAY,MAAM,cAAc,UAAU,OAAO,cAAc,EAAE;GACxF,wBAAwB,IAAI,0BAA0B,SAAS,CAAC;EAClE;EAEA,qBAAqB;GACnB,MAAM,EAAE,cAAc,sBAAsB,4BAA4B,KAAK,OAAO;GACpF,MAAM,WAAW,mBAAmB,aAAa,IAAI,GAAG,qBAAqB,IAAI,CAAC;GAClF,MAAM,UAAU,CAAC,GAAG,KAAK,WAAW,CAAC,CAAC,MAAM,UAAU,iBAAiB,WAAW,KAAK,GAAG,QAAQ,CAAC;GAInG,MAAM,UAAU,CAAC,GAAG,KAAK,WAAW,CAAC,CAAC,QAAQ,UAAU,MAAM,OAAO;GACrE,MAAM,SAAS,QAAQ,MAAM,UAAU,UAAU,OAAO,KAAK,QAAQ;GACrE,IAAI,CAAC,QAAQ;GAGb,KAAK,MAAM,SAAS,SAClB,IAAI,UAAU,QAAQ,MAAM,UAAU;GAIxC,IAAI,WAAW,SAAS;GAExB,MAAM,aAAa,KAAKE,aAAa,MAAM,cAAc,UAAU,OAAO,OAAO,EAAE;GACnF,wBAAwB,IAAI,0BAA0B,UAAU,CAAC;EACnE;EAEA,qBAAqB;GACnB,KAAK,MAAM,cAAc,CAAC,GAAG,KAAK,WAAW,GAAG,KAAK,iBAAiB,UAAU;EAClF;EAEA,qBAAqB;GACnB,KAAK,MAAM,cAAc,CAAC,GAAG,KAAK,WAAW,GAAG,KAAK,iBAAiB,UAAU;EAClF;CACF;CAEA,OAAO;AACT"}

package/dist/default/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/default/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/default/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/default/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/default/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/default/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/default/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/default/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/default/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/default/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/default/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;

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

@@ -1 +1 @@
-{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/end-of-stream.ts"],"sourcesContent":["/**\n * **Drive each `open → ended` transition of the MediaSource.** Calls\n * `MediaSource.endOfStream()` once the temporally last segments of every\n * active buffer actor's currently-loading track are fully appended and\n * the user has reached them — letting the browser finalize duration and\n * fire `ended` on the media element.\n *\n * Re-fires on every subsequent `open → ended → open` cycle. Per the MSE\n * spec, `appendBuffer()` after `endOfStream()` transitions the MediaSource\n * back to `'open'`; seek-back replays and back-buffer refills that re-load\n * earlier segments take this path, so the behavior must call\n * `endOfStream()` again once the last segments are reappended. The reactor's\n * `'preconditions-unmet'` ↔ `'eos-ready'` cycle *is* the re-arm mechanism:\n * a successful `endOfStream()` flips `mediaSource.readyState` to `'ended'`,\n * which (via the local `msIsOpen` signal) exits `'eos-ready'`; the next\n * `'open'` re-evaluates preconditions and may re-enter.\n *\n * # Tracking what's in the buffer\n *\n * Each `SourceBufferActor` knows which track it's currently loading via\n * `initTrackId` (set on the most recent `append-init` message) and which\n * segments it has appended. `deriveState` iterates over the available\n * buffer actors (`[videoBufferActor, audioBufferActor].filter(Boolean)`),\n * resolves each to its track via `findTrackById`, and checks that track's\n * last segment is appended. This means audio-only / video-only / mixed\n * configurations compose uniformly — the body iterates whatever's in\n * scope. No reliance on `selectedTrackId` slots: the actor's view IS the\n * source of truth for \"what's being loaded into this buffer.\"\n *\n * **Two-fire on mid-end ABR switches**: when a quality switch occurs near\n * end-of-stream, the actor's `initTrackId` still reflects the *old* track\n * until the new init segment is appended. The reactor may fire\n * `endOfStream()` against the old track's last-segment-appended state,\n * then the new init's `appendBuffer()` re-opens the MS, which re-arms us\n * to fire again once the new track's last segment lands. Functionally\n * correct (the browser re-fires `ended` after the re-arm), at the cost of\n * one extra call. Accepted as the price of dropping `selectedTrackId`\n * dependence.\n *\n * # Buffer-actor idle gate\n *\n * Each actor must be `'idle'` (no queued or in-flight tasks) before we\n * fire. `buffer.updating === false` alone is insufficient: for chunked\n * fMP4 streaming, `updateend` fires after each chunk while the actor's\n * for-await loop synchronously enqueues the next `appendBuffer()` — so\n * the buffer flips `!updating → updating` across a microtask boundary.\n * The actor's `'updating'` state spans the entire multi-chunk append, so\n * `actor.snapshot.value === 'idle'` is the canonical \"no more pending or\n * in-flight work\" oracle.\n *\n * This bet (actor models the pipeline; `mediaSource.sourceBuffers` models\n * DOM state) is durable as long as the segment loader is the sole writer\n * of `appendBuffer()` calls. A future loop-mode that auto-fetches earlier\n * segments mid-`ended` would require a broader coordination story\n * between SourceBuffers and the MediaSource — possibly via a\n * `MediaSourceActor` — and that's where this gate would want\n * re-evaluating.\n *\n * # currentTime gate\n *\n * `currentTime` must have reached (within {@link LAST_SEGMENT_REACHED_SLACK})\n * at least one active track's last segment startTime. Prevents `'eos-ready'`\n * entry when a back-buffer `remove()` / `appendBuffer()` briefly re-opens the\n * MediaSource while the user is mid-stream. HLS rendition time-alignment means\n * any active track works as the reference. The slack absorbs the near-end\n * playhead freeze (see the constant) so a tiny final segment doesn't deadlock.\n *\n * # MS readyState — local subscription\n *\n * The behavior subscribes to `mediaSource`'s readyState changes inside\n * its setup (via `onMediaSourceReadyStateChange`) and mirrors `'open'` to\n * a behavior-local `msIsOpen` signal that `deriveState` reads. No shared\n * `mediaSourceReadyState` slot dependency. Anticipates a future\n * `MediaSourceActor` whose snapshot would expose the same signal — the\n * consumer code wouldn't change.\n *\n * # `endOfStream` entry sequence\n *\n * 1. Wait for all SourceBuffers to be idle (DOM-level — defensive,\n *    should already hold given the actor-idle gate in `deriveState`).\n * 2. Set `mediaSource.duration` from `getMaxBufferedEnd` to match actual\n *    container timestamps (`endOfStream()` only clamps up implicitly;\n *    setting it explicitly here keeps the final value deterministic).\n * 3. Call `mediaSource.endOfStream()`.\n *\n * State-exit cleanup (`controller.abort()`) cancels any in-flight wait\n * on source unload, presentation replace, or behavior destroy.\n *\n * # Coordination with `updateMediaSourceDuration`\n *\n * `updateMediaSourceDuration` writes the initial `mediaSource.duration`\n * from `presentation.duration` once per source; this behavior writes the\n * final value from the buffered end. Decision domains don't overlap.\n */\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { effect } from '../../../core/signals/effect';\nimport { computed, type ReadonlySignal, signal } from '../../../core/signals/primitives';\nimport { getMaxBufferedEnd, waitForSourceBuffersReady } from '../../../media/dom/mse/duration';\nimport { isLastSegmentAppended } from '../../../media/dom/mse/end-of-stream';\nimport { onMediaSourceReadyStateChange } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { isResolvedTrack } from '../../../media/types';\nimport { findTrackById } from '../../../media/utils/tracks';\nimport type { SourceBufferActor } from '../../actors/dom/source-buffer';\n\nexport interface EndOfStreamState {\n  presentation?: MaybeResolvedPresentation;\n  currentTime?: number;\n}\n\nexport interface EndOfStreamContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n}\n\ntype EndOfStreamFsmState = 'preconditions-unmet' | 'eos-ready';\n\n/**\n * Slack (seconds) on the \"playhead has reached the last segment\" gate. A tiny final\n * segment (e.g. Apple's ~44ms last segment) starts right at the buffered end, and the\n * browser freezes the playhead ~50–70ms short of that end (its render horizon), so a\n * strict `currentTime >= lastSegStart` would never open — deadlocking `endOfStream`\n * (the MediaSource stays `'open'`, so the browser keeps the playhead frozen waiting for\n * data/EOS that never comes). This slack lets a playhead stalled just short of the final\n * segment still finalize. Firing slightly early is harmless: the last segment is already\n * appended (the gate above), so no more data is expected.\n */\nconst LAST_SEGMENT_REACHED_SLACK = 0.5;\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined,\n  msIsOpen: boolean,\n  videoBufferActor: SourceBufferActor | undefined,\n  audioBufferActor: SourceBufferActor | undefined,\n  currentTime: number | undefined\n): EndOfStreamFsmState {\n  if (!mediaSource || !presentation || !msIsOpen) return 'preconditions-unmet';\n\n  const actors = [videoBufferActor, audioBufferActor].filter((a): a is SourceBufferActor => a !== undefined);\n  // No active buffer actors means setup hasn't completed wiring yet.\n  if (actors.length === 0) return 'preconditions-unmet';\n\n  // Track the latest last-segment startTime across actors as the\n  // currentTime reference. HLS rendition time-alignment makes any active\n  // track usable; using the max is safest when timings drift slightly.\n  let lastSegStart: number | undefined;\n\n  for (const actor of actors) {\n    const snapshot = actor.snapshot.get();\n    if (snapshot.value !== 'idle') return 'preconditions-unmet';\n\n    const { initTrackId, segments: appended } = snapshot.context;\n    if (!initTrackId) return 'preconditions-unmet';\n\n    const track = findTrackById(presentation, initTrackId);\n    if (!track || !isResolvedTrack(track)) return 'preconditions-unmet';\n    if (!isLastSegmentAppended(track.segments, appended)) return 'preconditions-unmet';\n\n    if (track.segments.length > 0) {\n      const start = track.segments[track.segments.length - 1]!.startTime;\n      if (lastSegStart === undefined || start > lastSegStart) lastSegStart = start;\n    }\n  }\n\n  // Slack absorbs the near-end playhead freeze so a tiny final segment doesn't deadlock.\n  if (lastSegStart !== undefined && (currentTime ?? 0) < lastSegStart - LAST_SEGMENT_REACHED_SLACK) {\n    return 'preconditions-unmet';\n  }\n\n  return 'eos-ready';\n}\n\nfunction endOfStreamSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']>;\n    // See behavior definition for details on these optional context signals.\n    videoBufferActor?: ReadonlySignal<SourceBufferActor | undefined>;\n    audioBufferActor?: ReadonlySignal<SourceBufferActor | undefined>;\n  };\n}): () => void {\n  // Behavior-local mirror of `mediaSource.readyState === 'open'`. Subscribes\n  // to MS events whenever a MediaSource is in scope; tears down when the\n  // MS is swapped or the behavior destroys. Anticipates a future\n  // `MediaSourceActor` whose snapshot would expose the same value — the\n  // consumer code (deriveState) wouldn't change.\n  const msIsOpen = signal(false);\n  const cleanupMsListener = effect(() => {\n    const mediaSource = context.mediaSource.get();\n    if (!mediaSource) {\n      msIsOpen.set(false);\n      return;\n    }\n    msIsOpen.set(mediaSource.readyState === 'open');\n    const controller = new AbortController();\n    onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {\n      msIsOpen.set(rs === 'open');\n    });\n    return () => controller.abort();\n  });\n\n  const derivedStateSignal = computed(() =>\n    deriveState(\n      state.presentation.get(),\n      context.mediaSource.get(),\n      msIsOpen.get(),\n      context.videoBufferActor?.get(),\n      context.audioBufferActor?.get(),\n      state.currentTime.get()\n    )\n  );\n\n  const reactor = createMachineReactor<EndOfStreamFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'eos-ready': {\n        // entry body is auto-untracked. deriveState handles source resets\n        // and the MS readyState flip from 'open' to 'ended' that\n        // endOfStream() produces; this entry resolves the MSE-spec\n        // preconditions and binds its cleanup (abort) to state exit +\n        // destroy.\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const controller = new AbortController();\n\n          const endStreamWhenReady = async () => {\n            // Defensive: the actor-idle gate in deriveState should mean\n            // buffers are already settled, but a microtask boundary\n            // between deriveState's read and entry firing leaves a thin\n            // gap. The DOM-level wait closes it.\n            await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n            if (controller.signal.aborted) return;\n\n            // MSE spec: duration cannot be less than any buffered range, and\n            // endOfStream() will only clamp up implicitly. Setting it\n            // explicitly here from actual container timestamps keeps the\n            // final value deterministic for assets whose declared duration\n            // disagrees with the buffered end (common with CMAF).\n            const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);\n            if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;\n\n            mediaSource.endOfStream();\n          };\n\n          endStreamWhenReady().catch((err) => console.error('Failed to call endOfStream:', err));\n\n          return () => controller.abort();\n        },\n      },\n    },\n  });\n\n  return () => {\n    cleanupMsListener();\n    reactor.destroy();\n  };\n}\n\n/**\n * `endOfStream` uses a manual `Behavior<>` literal (rather than\n * `defineBehavior`) because it reads `videoBufferActor` /\n * `audioBufferActor` defensively without declaring them in its\n * contextKeys — those slots are contributed by other behaviors and\n * compose conditionally per engine variant. The `Behavior<>` literal\n * opts out of the exhaustiveness check so the typed context shape can\n * include the optional fields used at runtime. See the comment on\n * `endOfStreamSetup`'s context param for the discipline.\n */\nexport const endOfStream: Behavior<\n  {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  },\n  { mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']> }\n> = {\n  stateKeys: ['presentation', 'currentTime'],\n  contextKeys: ['mediaSource'],\n  setup: endOfStreamSetup,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiIA,MAAM,6BAA6B;AAEnC,SAAS,YACP,cACA,aACA,UACA,kBACA,kBACA,aACqB;CACrB,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,UAAU,OAAO;CAEvD,MAAM,SAAS,CAAC,kBAAkB,gBAAgB,CAAC,CAAC,QAAQ,MAA8B,MAAM,KAAA,CAAS;CAEzG,IAAI,OAAO,WAAW,GAAG,OAAO;CAKhC,IAAI;CAEJ,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM,SAAS,IAAI;EACpC,IAAI,SAAS,UAAU,QAAQ,OAAO;EAEtC,MAAM,EAAE,aAAa,UAAU,aAAa,SAAS;EACrD,IAAI,CAAC,aAAa,OAAO;EAEzB,MAAM,QAAQ,cAAc,cAAc,WAAW;EACrD,IAAI,CAAC,SAAS,CAAC,gBAAgB,KAAK,GAAG,OAAO;EAC9C,IAAI,CAAC,sBAAsB,MAAM,UAAU,QAAQ,GAAG,OAAO;EAE7D,IAAI,MAAM,SAAS,SAAS,GAAG;GAC7B,MAAM,QAAQ,MAAM,SAAS,MAAM,SAAS,SAAS,EAAE,CAAE;GACzD,IAAI,iBAAiB,KAAA,KAAa,QAAQ,cAAc,eAAe;EACzE;CACF;CAGA,IAAI,iBAAiB,KAAA,MAAc,eAAe,KAAK,eAAe,4BACpE,OAAO;CAGT,OAAO;AACT;AAEA,SAAS,iBAAiB,EACxB,OACA,WAYa;CAMb,MAAM,WAAW,OAAO,KAAK;CAC7B,MAAM,oBAAoB,aAAa;EACrC,MAAM,cAAc,QAAQ,YAAY,IAAI;EAC5C,IAAI,CAAC,aAAa;GAChB,SAAS,IAAI,KAAK;GAClB;EACF;EACA,SAAS,IAAI,YAAY,eAAe,MAAM;EAC9C,MAAM,aAAa,IAAI,gBAAgB;EACvC,8BAA8B,aAAa,WAAW,SAAS,OAAO;GACpE,SAAS,IAAI,OAAO,MAAM;EAC5B,CAAC;EACD,aAAa,WAAW,MAAM;CAChC,CAAC;CAED,MAAM,qBAAqB,eACzB,YACE,MAAM,aAAa,IAAI,GACvB,QAAQ,YAAY,IAAI,GACxB,SAAS,IAAI,GACb,QAAQ,kBAAkB,IAAI,GAC9B,QAAQ,kBAAkB,IAAI,GAC9B,MAAM,YAAY,IAAI,CACxB,CACF;CAEA,MAAM,UAAU,qBAA0C;EACxD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,aAAa,EAMX,aAAa;IACX,MAAM,cAAc,QAAQ,YAAY,IAAI;IAC5C,MAAM,aAAa,IAAI,gBAAgB;IAEvC,MAAM,qBAAqB,YAAY;KAKrC,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;KAC5E,IAAI,WAAW,OAAO,SAAS;KAO/B,MAAM,cAAc,kBAAkB,YAAY,aAAa;KAC/D,IAAI,cAAc,GAAG,YAAY,WAAW;KAE5C,YAAY,YAAY;IAC1B;IAEA,mBAAmB,CAAC,CAAC,OAAO,QAAQ,QAAQ,MAAM,+BAA+B,GAAG,CAAC;IAErF,aAAa,WAAW,MAAM;GAChC,EACF;EACF;CACF,CAAC;CAED,aAAa;EACX,kBAAkB;EAClB,QAAQ,QAAQ;CAClB;AACF;;;;;;;;;;;AAYA,MAAa,cAMT;CACF,WAAW,CAAC,gBAAgB,aAAa;CACzC,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT"}
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/end-of-stream.ts"],"sourcesContent":["/**\n * **Drive each `open → ended` transition of the MediaSource.** Calls\n * `MediaSource.endOfStream()` once every active buffer actor's\n * currently-loading track is *complete* (finite `Track.duration` — the parser's\n * completeness signal), its temporally last segments are fully appended, and\n * the user has reached them — letting the browser finalize duration and\n * fire `ended` on the media element. The completeness gate keeps it inert for\n * ongoing live (`Track.duration === Infinity`), whose \"last segment\" is only\n * the rolling edge; a live stream opts in when its duration turns finite.\n *\n * Re-fires on every subsequent `open → ended → open` cycle. Per the MSE\n * spec, `appendBuffer()` after `endOfStream()` transitions the MediaSource\n * back to `'open'`; seek-back replays and back-buffer refills that re-load\n * earlier segments take this path, so the behavior must call\n * `endOfStream()` again once the last segments are reappended. The reactor's\n * `'preconditions-unmet'` ↔ `'eos-ready'` cycle *is* the re-arm mechanism:\n * a successful `endOfStream()` flips `mediaSource.readyState` to `'ended'`,\n * which (via the local `msIsOpen` signal) exits `'eos-ready'`; the next\n * `'open'` re-evaluates preconditions and may re-enter.\n *\n * # Tracking what's in the buffer\n *\n * Each `SourceBufferActor` knows which track it's currently loading via\n * `initTrackId` (set on the most recent `append-init` message) and which\n * segments it has appended. `deriveState` iterates over the available\n * buffer actors (`[videoBufferActor, audioBufferActor].filter(Boolean)`),\n * resolves each to its track via `findTrackById`, and checks that track's\n * last segment is appended. This means audio-only / video-only / mixed\n * configurations compose uniformly — the body iterates whatever's in\n * scope. No reliance on `selectedTrackId` slots: the actor's view IS the\n * source of truth for \"what's being loaded into this buffer.\"\n *\n * **Two-fire on mid-end ABR switches**: when a quality switch occurs near\n * end-of-stream, the actor's `initTrackId` still reflects the *old* track\n * until the new init segment is appended. The reactor may fire\n * `endOfStream()` against the old track's last-segment-appended state,\n * then the new init's `appendBuffer()` re-opens the MS, which re-arms us\n * to fire again once the new track's last segment lands. Functionally\n * correct (the browser re-fires `ended` after the re-arm), at the cost of\n * one extra call. Accepted as the price of dropping `selectedTrackId`\n * dependence.\n *\n * # Buffer-actor idle gate\n *\n * Each actor must be `'idle'` (no queued or in-flight tasks) before we\n * fire. `buffer.updating === false` alone is insufficient: for chunked\n * fMP4 streaming, `updateend` fires after each chunk while the actor's\n * for-await loop synchronously enqueues the next `appendBuffer()` — so\n * the buffer flips `!updating → updating` across a microtask boundary.\n * The actor's `'updating'` state spans the entire multi-chunk append, so\n * `actor.snapshot.value === 'idle'` is the canonical \"no more pending or\n * in-flight work\" oracle.\n *\n * This bet (actor models the pipeline; `mediaSource.sourceBuffers` models\n * DOM state) is durable as long as the segment loader is the sole writer\n * of `appendBuffer()` calls. A future loop-mode that auto-fetches earlier\n * segments mid-`ended` would require a broader coordination story\n * between SourceBuffers and the MediaSource — possibly via a\n * `MediaSourceActor` — and that's where this gate would want\n * re-evaluating.\n *\n * # currentTime gate\n *\n * `currentTime` must have reached (within {@link LAST_SEGMENT_REACHED_SLACK})\n * at least one active track's last segment startTime. Prevents `'eos-ready'`\n * entry when a back-buffer `remove()` / `appendBuffer()` briefly re-opens the\n * MediaSource while the user is mid-stream. HLS rendition time-alignment means\n * any active track works as the reference. The slack absorbs the near-end\n * playhead freeze (see the constant) so a tiny final segment doesn't deadlock.\n *\n * # MS readyState — local subscription\n *\n * The behavior subscribes to `mediaSource`'s readyState changes inside\n * its setup (via `onMediaSourceReadyStateChange`) and mirrors `'open'` to\n * a behavior-local `msIsOpen` signal that `deriveState` reads. No shared\n * `mediaSourceReadyState` slot dependency. Anticipates a future\n * `MediaSourceActor` whose snapshot would expose the same signal — the\n * consumer code wouldn't change.\n *\n * # `endOfStream` entry sequence\n *\n * 1. Wait for all SourceBuffers to be idle (DOM-level — defensive,\n *    should already hold given the actor-idle gate in `deriveState`).\n * 2. Set `mediaSource.duration` from `getMaxBufferedEnd` to match actual\n *    container timestamps (`endOfStream()` only clamps up implicitly;\n *    setting it explicitly here keeps the final value deterministic).\n * 3. Call `mediaSource.endOfStream()`.\n *\n * State-exit cleanup (`controller.abort()`) cancels any in-flight wait\n * on source unload, presentation replace, or behavior destroy.\n *\n * # Coordination with `updateMediaSourceDuration`\n *\n * `updateMediaSourceDuration` writes the initial `mediaSource.duration`\n * from `presentation.duration` once per source; this behavior writes the\n * final value from the buffered end. Decision domains don't overlap.\n */\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { effect } from '../../../core/signals/effect';\nimport { computed, type ReadonlySignal, signal } from '../../../core/signals/primitives';\nimport { getMaxBufferedEnd, waitForSourceBuffersReady } from '../../../media/dom/mse/duration';\nimport { isLastSegmentAppended } from '../../../media/dom/mse/end-of-stream';\nimport { onMediaSourceReadyStateChange } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { isResolvedTrack } from '../../../media/types';\nimport { findTrackById } from '../../../media/utils/tracks';\nimport type { SourceBufferActor } from '../../actors/dom/source-buffer';\n\nexport interface EndOfStreamState {\n  presentation?: MaybeResolvedPresentation;\n  currentTime?: number;\n}\n\nexport interface EndOfStreamContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n}\n\ntype EndOfStreamFsmState = 'preconditions-unmet' | 'eos-ready';\n\n/**\n * Slack (seconds) on the \"playhead has reached the last segment\" gate. A tiny final\n * segment (e.g. Apple's ~44ms last segment) starts right at the buffered end, and the\n * browser freezes the playhead ~50–70ms short of that end (its render horizon), so a\n * strict `currentTime >= lastSegStart` would never open — deadlocking `endOfStream`\n * (the MediaSource stays `'open'`, so the browser keeps the playhead frozen waiting for\n * data/EOS that never comes). This slack lets a playhead stalled just short of the final\n * segment still finalize. Firing slightly early is harmless: the last segment is already\n * appended (the gate above), so no more data is expected.\n */\nconst LAST_SEGMENT_REACHED_SLACK = 0.5;\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined,\n  msIsOpen: boolean,\n  videoBufferActor: SourceBufferActor | undefined,\n  audioBufferActor: SourceBufferActor | undefined,\n  currentTime: number | undefined\n): EndOfStreamFsmState {\n  if (!mediaSource || !presentation || !msIsOpen) return 'preconditions-unmet';\n\n  const actors = [videoBufferActor, audioBufferActor].filter((a): a is SourceBufferActor => a !== undefined);\n  // No active buffer actors means setup hasn't completed wiring yet.\n  if (actors.length === 0) return 'preconditions-unmet';\n\n  // Track the latest last-segment startTime across actors as the\n  // currentTime reference. HLS rendition time-alignment makes any active\n  // track usable; using the max is safest when timings drift slightly.\n  let lastSegStart: number | undefined;\n\n  for (const actor of actors) {\n    const snapshot = actor.snapshot.get();\n    if (snapshot.value !== 'idle') return 'preconditions-unmet';\n\n    const { initTrackId, segments: appended } = snapshot.context;\n    if (!initTrackId) return 'preconditions-unmet';\n\n    const track = findTrackById(presentation, initTrackId);\n    if (!track || !isResolvedTrack(track)) return 'preconditions-unmet';\n    // Only a complete playlist has a true last segment: firing on an ongoing\n    // live window would pin a finite (live-edge) duration and end the stream,\n    // only for the next reload's appends to reopen it and re-fire on a loop.\n    // Independent of the currentTime slack below — this asks \"is there an end at\n    // all,\" the slack asks \"has the playhead effectively reached it.\"\n    if (!Number.isFinite(track.duration)) return 'preconditions-unmet';\n    if (!isLastSegmentAppended(track.segments, appended)) return 'preconditions-unmet';\n\n    if (track.segments.length > 0) {\n      const start = track.segments[track.segments.length - 1]!.startTime;\n      if (lastSegStart === undefined || start > lastSegStart) lastSegStart = start;\n    }\n  }\n\n  // Slack absorbs the near-end playhead freeze so a tiny final segment doesn't deadlock.\n  if (lastSegStart !== undefined && (currentTime ?? 0) < lastSegStart - LAST_SEGMENT_REACHED_SLACK) {\n    return 'preconditions-unmet';\n  }\n\n  return 'eos-ready';\n}\n\nfunction endOfStreamSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']>;\n    // See behavior definition for details on these optional context signals.\n    videoBufferActor?: ReadonlySignal<SourceBufferActor | undefined>;\n    audioBufferActor?: ReadonlySignal<SourceBufferActor | undefined>;\n  };\n}): () => void {\n  // Behavior-local mirror of `mediaSource.readyState === 'open'`. Subscribes\n  // to MS events whenever a MediaSource is in scope; tears down when the\n  // MS is swapped or the behavior destroys. Anticipates a future\n  // `MediaSourceActor` whose snapshot would expose the same value — the\n  // consumer code (deriveState) wouldn't change.\n  const msIsOpen = signal(false);\n  const cleanupMsListener = effect(() => {\n    const mediaSource = context.mediaSource.get();\n    if (!mediaSource) {\n      msIsOpen.set(false);\n      return;\n    }\n    msIsOpen.set(mediaSource.readyState === 'open');\n    const controller = new AbortController();\n    onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {\n      msIsOpen.set(rs === 'open');\n    });\n    return () => controller.abort();\n  });\n\n  const derivedStateSignal = computed(() =>\n    deriveState(\n      state.presentation.get(),\n      context.mediaSource.get(),\n      msIsOpen.get(),\n      context.videoBufferActor?.get(),\n      context.audioBufferActor?.get(),\n      state.currentTime.get()\n    )\n  );\n\n  const reactor = createMachineReactor<EndOfStreamFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'eos-ready': {\n        // entry body is auto-untracked. deriveState handles source resets\n        // and the MS readyState flip from 'open' to 'ended' that\n        // endOfStream() produces; this entry resolves the MSE-spec\n        // preconditions and binds its cleanup (abort) to state exit +\n        // destroy.\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const controller = new AbortController();\n\n          const endStreamWhenReady = async () => {\n            // Defensive: the actor-idle gate in deriveState should mean\n            // buffers are already settled, but a microtask boundary\n            // between deriveState's read and entry firing leaves a thin\n            // gap. The DOM-level wait closes it.\n            await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n            if (controller.signal.aborted) return;\n\n            // MSE spec: duration cannot be less than any buffered range, and\n            // endOfStream() will only clamp up implicitly. Setting it\n            // explicitly here from actual container timestamps keeps the\n            // final value deterministic for assets whose declared duration\n            // disagrees with the buffered end (common with CMAF).\n            const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);\n            if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;\n\n            mediaSource.endOfStream();\n          };\n\n          endStreamWhenReady().catch((err) => console.error('Failed to call endOfStream:', err));\n\n          return () => controller.abort();\n        },\n      },\n    },\n  });\n\n  return () => {\n    cleanupMsListener();\n    reactor.destroy();\n  };\n}\n\n/**\n * `endOfStream` uses a manual `Behavior<>` literal (rather than\n * `defineBehavior`) because it reads `videoBufferActor` /\n * `audioBufferActor` defensively without declaring them in its\n * contextKeys — those slots are contributed by other behaviors and\n * compose conditionally per engine variant. The `Behavior<>` literal\n * opts out of the exhaustiveness check so the typed context shape can\n * include the optional fields used at runtime. See the comment on\n * `endOfStreamSetup`'s context param for the discipline.\n */\nexport const endOfStream: Behavior<\n  {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  },\n  { mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']> }\n> = {\n  stateKeys: ['presentation', 'currentTime'],\n  contextKeys: ['mediaSource'],\n  setup: endOfStreamSetup,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoIA,MAAM,6BAA6B;AAEnC,SAAS,YACP,cACA,aACA,UACA,kBACA,kBACA,aACqB;CACrB,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,UAAU,OAAO;CAEvD,MAAM,SAAS,CAAC,kBAAkB,gBAAgB,CAAC,CAAC,QAAQ,MAA8B,MAAM,KAAA,CAAS;CAEzG,IAAI,OAAO,WAAW,GAAG,OAAO;CAKhC,IAAI;CAEJ,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM,SAAS,IAAI;EACpC,IAAI,SAAS,UAAU,QAAQ,OAAO;EAEtC,MAAM,EAAE,aAAa,UAAU,aAAa,SAAS;EACrD,IAAI,CAAC,aAAa,OAAO;EAEzB,MAAM,QAAQ,cAAc,cAAc,WAAW;EACrD,IAAI,CAAC,SAAS,CAAC,gBAAgB,KAAK,GAAG,OAAO;EAM9C,IAAI,CAAC,OAAO,SAAS,MAAM,QAAQ,GAAG,OAAO;EAC7C,IAAI,CAAC,sBAAsB,MAAM,UAAU,QAAQ,GAAG,OAAO;EAE7D,IAAI,MAAM,SAAS,SAAS,GAAG;GAC7B,MAAM,QAAQ,MAAM,SAAS,MAAM,SAAS,SAAS,EAAE,CAAE;GACzD,IAAI,iBAAiB,KAAA,KAAa,QAAQ,cAAc,eAAe;EACzE;CACF;CAGA,IAAI,iBAAiB,KAAA,MAAc,eAAe,KAAK,eAAe,4BACpE,OAAO;CAGT,OAAO;AACT;AAEA,SAAS,iBAAiB,EACxB,OACA,WAYa;CAMb,MAAM,WAAW,OAAO,KAAK;CAC7B,MAAM,oBAAoB,aAAa;EACrC,MAAM,cAAc,QAAQ,YAAY,IAAI;EAC5C,IAAI,CAAC,aAAa;GAChB,SAAS,IAAI,KAAK;GAClB;EACF;EACA,SAAS,IAAI,YAAY,eAAe,MAAM;EAC9C,MAAM,aAAa,IAAI,gBAAgB;EACvC,8BAA8B,aAAa,WAAW,SAAS,OAAO;GACpE,SAAS,IAAI,OAAO,MAAM;EAC5B,CAAC;EACD,aAAa,WAAW,MAAM;CAChC,CAAC;CAED,MAAM,qBAAqB,eACzB,YACE,MAAM,aAAa,IAAI,GACvB,QAAQ,YAAY,IAAI,GACxB,SAAS,IAAI,GACb,QAAQ,kBAAkB,IAAI,GAC9B,QAAQ,kBAAkB,IAAI,GAC9B,MAAM,YAAY,IAAI,CACxB,CACF;CAEA,MAAM,UAAU,qBAA0C;EACxD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,aAAa,EAMX,aAAa;IACX,MAAM,cAAc,QAAQ,YAAY,IAAI;IAC5C,MAAM,aAAa,IAAI,gBAAgB;IAEvC,MAAM,qBAAqB,YAAY;KAKrC,MAAM,0BAA0B,YAAY,eAAe,WAAW,MAAM;KAC5E,IAAI,WAAW,OAAO,SAAS;KAO/B,MAAM,cAAc,kBAAkB,YAAY,aAAa;KAC/D,IAAI,cAAc,GAAG,YAAY,WAAW;KAE5C,YAAY,YAAY;IAC1B;IAEA,mBAAmB,CAAC,CAAC,OAAO,QAAQ,QAAQ,MAAM,+BAA+B,GAAG,CAAC;IAErF,aAAa,WAAW,MAAM;GAChC,EACF;EACF;CACF,CAAC;CAED,aAAa;EACX,kBAAkB;EAClB,QAAQ,QAAQ;CAClB;AACF;;;;;;;;;;;AAYA,MAAa,cAMT;CACF,WAAW,CAAC,gBAAgB,aAAa;CACzC,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT"}