@videojs/spf 10.0.0-beta.3 → 10.0.0-beta.30

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":";;;;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/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,34 @@
+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.
+ * @fires contentdatachange - Fired when the derived `contentData` changes. Read `contentData` 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":";;;UAWiB;EACf;EACA,QAAQ;;cAGG,sBAAsB;UAKlB,oBAAoB;WAC1B,aAAa;;;;;;;;;;;;;;;;;;;iBAoBR,cAAc,aAAa,kBAAkB,WAAW,OAsGpC,YAAY,MAAM;WACzC"}

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

@@ -0,0 +1,105 @@
+import { shallowEqual } from "@videojs/utils/object";
+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.
+* @fires contentdatachange - Fired when the derived `contentData` changes. Read `contentData` 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;
+		#contentData = {};
+		/**
+		* 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;
+			const contentDataChanged = this.#refreshContentData();
+			super.src = source && (createMuxVideoURL(source) ?? source.src) || "";
+			this.dispatchEvent?.(new Event("sourcechange"));
+			if (contentDataChanged) this.dispatchEvent?.(new Event("contentdatachange"));
+		}
+		/**
+		* Image URLs `source` describes rather than plays: `poster` from its `poster`
+		* params, `storyboard` from its `storyboard` params.
+		*
+		* Derived from `source` and nothing else. The same object is handed back
+		* until one of those URLs changes, and `contentdatachange` announces it when
+		* it does. Nothing here is applied for you.
+		*/
+		get contentData() {
+			return this.#contentData;
+		}
+		/** Rebuild the derived bag, reporting whether anything about it changed. */
+		#refreshContentData() {
+			const poster = createMuxPosterURL(this.#source);
+			const storyboard = createMuxStoryboardURL(this.#source);
+			const next = {
+				...poster && { poster },
+				...storyboard && { storyboard }
+			};
+			if (shallowEqual(this.#contentData, next)) return false;
+			this.#contentData = next;
+			return true;
+		}
+	}
+	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","#refreshContentData","#contentData"],"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 { shallowEqual } from '@videojs/utils/object';\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 * @fires contentdatachange - Fired when the derived `contentData` changes. Read `contentData` 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    #contentData: MuxContentData = {};\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\n      // Refresh the bag before announcing `sourcechange`, because listeners read\n      // `contentData` from that event. Announcing its own change waits until\n      // after, so `src` is in step by the time either event fires.\n      const contentDataChanged = this.#refreshContentData();\n\n      super.src = (source && (createMuxVideoURL(source) ?? source.src)) || '';\n\n      this.dispatchEvent?.(new Event('sourcechange'));\n\n      if (contentDataChanged) this.dispatchEvent?.(new Event('contentdatachange'));\n    }\n\n    /**\n     * Image URLs `source` describes rather than plays: `poster` from its `poster`\n     * params, `storyboard` from its `storyboard` params.\n     *\n     * Derived from `source` and nothing else. The same object is handed back\n     * until one of those URLs changes, and `contentdatachange` announces it when\n     * it does. Nothing here is applied for you.\n     */\n    get contentData(): MuxContentData {\n      return this.#contentData;\n    }\n\n    /** Rebuild the derived bag, reporting whether anything about it changed. */\n    #refreshContentData(): boolean {\n      const poster = createMuxPosterURL(this.#source);\n      const storyboard = createMuxStoryboardURL(this.#source);\n\n      const next: MuxContentData = {\n        ...(poster && { poster }),\n        ...(storyboard && { storyboard }),\n      };\n\n      if (shallowEqual(this.#contentData, next)) return false;\n\n      this.#contentData = next;\n      return true;\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":";;;AAgBA,MAAa,uBAAsC;CACjD,KAAK;CACL,QAAQ;AACV;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,cAA6C,WAAiB;CAC5E,MAAM,qBAAqB,UAAU;;;;;;;;;;;EAWnC,WAAW,6BAAiD;GAC1D,OAAO;EACT;EAEA,UAAgC,qBAAqB;EACrD,eAA+B,CAAC;;;;;;;;;;EAWhC,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;GAKf,MAAM,qBAAqB,KAAKC,oBAAoB;GAEpD,MAAM,MAAO,WAAW,kBAAkB,MAAM,KAAK,OAAO,QAAS;GAErE,KAAK,gBAAgB,IAAI,MAAM,cAAc,CAAC;GAE9C,IAAI,oBAAoB,KAAK,gBAAgB,IAAI,MAAM,mBAAmB,CAAC;EAC7E;;;;;;;;;EAUA,IAAI,cAA8B;GAChC,OAAO,KAAKC;EACd;;EAGA,sBAA+B;GAC7B,MAAM,SAAS,mBAAmB,KAAKF,OAAO;GAC9C,MAAM,aAAa,uBAAuB,KAAKA,OAAO;GAEtD,MAAM,OAAuB;IAC3B,GAAI,UAAU,EAAE,OAAO;IACvB,GAAI,cAAc,EAAE,WAAW;GACjC;GAEA,IAAI,aAAa,KAAKE,cAAc,IAAI,GAAG,OAAO;GAElD,KAAKA,eAAe;GACpB,OAAO;EACT;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/calculate-presentation-duration.d.ts

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

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

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

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

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

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

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

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

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

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, peek, type ReadonlySignal, type Signal, update } from '../../core/signals/primitives';\nimport type { SvtaError } from '../../media/errors';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';\nimport type { SelectionRule } from '../primitives/selection-rules';\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 * A \"constraint\" that reports a type the source carries **no** renditions of, for\n * a composition that can't play without it.\n *\n * Strange on purpose, and the strangeness is the point: it never constrains\n * anything, always returning its input untouched. It is shaped as a rule so a\n * composition opts in by adding it to `constraints` — nothing to thread through\n * config, and no cost at all to a composition that leaves it out.\n *\n * **Belongs last in the chain.** A constraint sees the list as it stands at its\n * own position, so only at the tail does an empty input mean \"nothing playable\n * here\" — none of this type offered, or the constraints ahead pruned them all.\n *\n * These are the failures no per-rendition cause can report: causes come from\n * `reportUnsupportedTrackConditions` as each media playlist resolves, and a\n * rendition pruned before selection never resolves. Container and encryption\n * aren't knowable until one does; CODECS is, so an undecodable ladder isn't.\n *\n * Idempotent because the constraint chain runs inside a `computed` that re-derives\n * on every `presentation` write — segment appends and live reloads included — and\n * the sequence deliberately keeps duplicates. `peek` is what keeps that computed\n * from subscribing to the slot this writes.\n *\n * @example\n * // engine-background-video.ts — video-only, so a source with none can't play\n * constraints: [excludeUnplayableTracks, reportAbsentTrackType(SVTA_NO_SUPPORTED_VIDEO_TRACK)]\n */\nexport function reportAbsentTrackType<T>(code: number): SelectionRule<T, ErrorEmitterState> {\n  return (tracks, { state }) => {\n    const reported = state.errors && peek(state.errors);\n    if (!tracks.length && !reported?.some((error) => error.code === code)) {\n      emitError(state, { code });\n    }\n    return tracks;\n  };\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,sBAAyB,MAAmD;CAC1F,QAAQ,QAAQ,EAAE,YAAY;EAC5B,MAAM,WAAW,MAAM,UAAU,KAAK,MAAM,MAAM;EAClD,IAAI,CAAC,OAAO,UAAU,CAAC,UAAU,MAAM,UAAU,MAAM,SAAS,IAAI,GAClE,UAAU,OAAO,EAAE,KAAK,CAAC;EAE3B,OAAO;CACT;AACF;;;;;;;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"}