@videojs/spf 10.0.0-beta.31 → 10.0.0-beta.32

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

@@ -6,33 +6,29 @@ const muxMediaDefaultProps = {
 	source: null
 };
 /**
-* Mux identity over any SPF Media: the structured `source`, the `src` derived
-* from it, and the image URLs it describes.
+* 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.
+* 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.
+* 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 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>`.
+		* 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.
+		* 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.";
@@ -40,13 +36,11 @@ function MuxMediaMixin(BaseClass) {
 		#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`.
+		* 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.
+		* 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;
@@ -56,10 +50,9 @@ function MuxMediaMixin(BaseClass) {
 			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.
+		* 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;
@@ -74,12 +67,11 @@ function MuxMediaMixin(BaseClass) {
 			if (contentDataChanged) this.dispatchEvent?.(new Event("contentdatachange"));
 		}
 		/**
-		* Image URLs `source` describes rather than plays: `poster` from its `poster`
-		* params, `storyboard` from its `storyboard` params.
+		* 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.
+		* 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;

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

@@ -1 +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"}
+{"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 from it, and the image URLs it describes.\n *\n * Everything here is Mux identity, so it carries no engine and both flavors get it unchanged — the video Media over the\n * full HLS engine, the audio-only Media 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 on, only a common `src` accessor to\n * write through.\n *\n * Unlike the hls.js-backed `MuxMedia`, there is no inherited `source` to delegate to — the SPF Medias know only `src` —\n * so this owns the structured 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\n *   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 hls.js-backed Mux Media plays the MPEG-TS and\n     * DRM-protected sources that 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 through three of them —\n     * `@videojs/html`, `@videojs/react`, and this package — and each has a different counterpart. The flavor suffix is\n     * the one thing 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 (`https://stream.mux.com/<playback-id>.m3u8?...`) extracts the\n     * playback ID 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 signed `poster`, `storyboard`, and\n     * `drm` tokens are scoped to a playback ID, 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 domain, and `playback` params\n     * (appended as `snake_case` query params). A `playback.token` replaces all other params — signed URLs bake them\n     * into the 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` params, `storyboard` from its\n     * `storyboard` params.\n     *\n     * Derived from `source` and nothing else. The same object is handed back until one of those URLs changes, and\n     * `contentdatachange` announces it when 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      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;;;;;;;;;;;;;;;;AAqBA,SAAgB,cAA6C,WAAiB;CAC5E,MAAM,qBAAqB,UAAU;;;;;;;;;EASnC,WAAW,6BAAiD;GAC1D,OAAO;EACT;EAEA,UAAgC,qBAAqB;EACrD,eAA+B,CAAC;;;;;;;;EAShC,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;;;;;;EAOA,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;;;;;;;;EASA,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;GACA,IAAI,aAAa,KAAKE,cAAc,IAAI,GAAG,OAAO;GAElD,KAAKA,eAAe;GACpB,OAAO;EACT;CACF;CAIA,OAAO;AAGT"}

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

@@ -5,16 +5,14 @@ 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.
+* 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.
+* `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

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

@@ -1 +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"}
+{"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, same `src`/`source` relationship,\n * same derived `contentData` — over a different engine, though named for the flavor rather than sharing that class's\n * name. It carries no `engine` or `preferPlayback`: SPF publishes no engine-shaped config for a consumer to pass, so\n * the source is Mux identity and nothing else.\n *\n * `source.drm` is accepted but inert. SPF prunes encrypted renditions and reports unsupported DRM, and\n * `alternativeMediaSuggestion` points at the hls.js-backed import, so a protected source fails with copy that says\n * where to go.\n */\nexport class MuxVideoMedia extends MuxVideoMediaBase {}\n"],"mappings":";;;AAGA,MAAM,oBAAoB,cAAc,aAAa;;;;;;;;;;;;;AAcrD,IAAa,gBAAb,cAAmC,kBAAkB,CAAC"}

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

@@ -16,14 +16,11 @@ function calculatePresentationDurationSetup({ state, config }) {
 	});
 }
 /**
-* `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.
+* `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"],

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

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

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

@@ -4,46 +4,37 @@ import { createMachineReactor } from "../../core/reactors/create-machine-reactor
 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.
+* **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*.
+* 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.
+* 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.
+* 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.
+* 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.
+* 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).
+* 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);
@@ -51,31 +42,27 @@ function emitError(state, error) {
 	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.
+* 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
+* 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.
+* **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.
+* 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.
+* 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)]
+*   // 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 }) => {
@@ -88,7 +75,7 @@ function reportAbsentTrackType(code) {
 * Own `errors` for the resolved source's lifetime.
 *
 * @example
-* const reactor = collectErrors.setup({ state });
+*   const reactor = collectErrors.setup({ state });
 */
 const collectErrors = defineBehavior({
 	stateKeys: ["presentation", "errors"],

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

@@ -1 +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"}
+{"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 {@link emitError}; this behavior owns the slot and its\n * per-source lifecycle, clearing it on exit so a new source starts clean and the sequence can't grow unbounded across a\n * session.\n *\n * Same split as `setupFailoverMonitor` and `failedCdns`: writes come from wherever the condition is detected, one\n * behavior owns the slot. Deliberately 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 is why this is a lifecycle owner\n * rather than an error _handler_.\n *\n * Clearing binds to _exit_ of `presentation-resolved`, mirroring the sibling mixins' clear-on-teardown (`emptied` /\n * `MEDIA_DETACHED`). A live reload swaps 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 resolved→resolved source swap that never passes\n * through unresolved carries the prior source's errors forward; `resolve-track` guards the same transition with a\n * 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 signal-free in `media/errors`; only the write\n * seam lives here, with the slot 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 through this seam without declaring\n * ownership in its own typed slice, and 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 composed. Replaces the array rather than\n * mutating it, so signal consumers 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 appends.\n *\n * Every emission is logged, deliberately _before_ the owner check. A condition emitted with no `collectErrors` composed\n * 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\n * the same check would hide exactly what's worth seeing. Emissions that _are_ collected still get logged, because\n * reaching `state.errors` is no guarantee of reaching a person: only _verdicts_ are promoted to the media surface, so\n * every 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 package (`resolve-presentation`,\n * `track-switching`, the segment actors).\n */\nexport function emitError(state: ErrorEmitterState, error: SvtaError): void {\n  console.error('[spf] reported condition', error);\n\n  if (!state.errors) return;\n\n  update(state.errors, (errors) => [...(errors ?? []), error]);\n}\n\n/**\n * A \"constraint\" that reports a type the source carries **no** renditions of, for a composition that can't play without\n * it.\n *\n * Strange on purpose, and the strangeness is the point: it never constrains anything, always returning its input\n * untouched. It is shaped as a rule so a 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 own position, so only at the tail does\n * an empty input mean \"nothing playable 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 `reportUnsupportedTrackConditions` as each\n * media playlist resolves, and a rendition pruned before selection never resolves. Container and encryption aren't\n * 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 on every `presentation` write —\n * segment appends and live reloads included — and the sequence deliberately keeps duplicates. `peek` is what keeps that\n * computed 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\n    if (!tracks.length && !reported?.some((error) => error.code === code)) {\n      emitError(state, { code });\n    }\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAgB,UAAU,OAA0B,OAAwB;CAC1E,QAAQ,MAAM,4BAA4B,KAAK;CAE/C,IAAI,CAAC,MAAM,QAAQ;CAEnB,OAAO,MAAM,SAAS,WAAW,CAAC,GAAI,UAAU,CAAC,GAAI,KAAK,CAAC;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,sBAAyB,MAAmD;CAC1F,QAAQ,QAAQ,EAAE,YAAY;EAC5B,MAAM,WAAW,MAAM,UAAU,KAAK,MAAM,MAAM;EAElD,IAAI,CAAC,OAAO,UAAU,CAAC,UAAU,MAAM,UAAU,MAAM,SAAS,IAAI,GAClE,UAAU,OAAO,EAAE,KAAK,CAAC;EAG3B,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"}

package/dist/default/playback/behaviors/derive-cdn-priority.js

@@ -5,38 +5,31 @@ import { isResolvedPresentation } from "../../media/types/index.js";
 import { getCdnId, getOrderedCdnIds } from "../../media/utils/cdn.js";
 //#region src/playback/behaviors/derive-cdn-priority.ts
 /**
-* **Session-level CDN priority.** While a presentation is resolved, owns the
-* `cdnPriority` signal: the distinct CDNs the source is served from (origin of
-* each track's URL), in manifest priority order — most-preferred first. Cleared
-* on src unload. The name mirrors HLS content steering's `PATHWAY-PRIORITY`.
+* **Session-level CDN priority.** While a presentation is resolved, owns the `cdnPriority` signal: the distinct CDNs
+* the source is served from (origin of each track's URL), in manifest priority order — most-preferred first. Cleared on
+* src unload. The name mirrors HLS content steering's `PATHWAY-PRIORITY`.
 *
-* Redundant-stream sources (e.g. Mux's `?redundant_streams=true`) list the same
-* content on multiple hosts, so the candidate tracks already include one variant
-* per CDN. This behavior publishes *which* CDNs exist and their priority; the
-* `preferActiveCdn` scope rule in `track-switching` reads `cdnPriority` and
-* narrows each type's candidates to the first CDN with surviving tracks — so
-* video / audio / text all resolve from one host (the shared list is the
+* Redundant-stream sources (e.g. Mux's `?redundant_streams=true`) list the same content on multiple hosts, so the
+* candidate tracks already include one variant per CDN. This behavior publishes _which_ CDNs exist and their priority;
+* the `preferActiveCdn` scope rule in `track-switching` reads `cdnPriority` and narrows each type's candidates to the
+* first CDN with surviving tracks — so video / audio / text all resolve from one host (the shared list is the
 * per-presentation coherence guarantee).
 *
-* The "active" CDN is not stored — it's derived by the scope as the
-* highest-priority entry in `cdnPriority` that still has tracks after the
-* constraints pre-pass. That makes failover a pure consequence of the (future)
-* failed-CDN constraint: when the primary's tracks are pruned during cooldown,
-* the scope falls to the next CDN; when the primary recovers, it snaps back.
-* Content steering, when it lands, reorders `cdnPriority` (pathway priority as a
-* sort key).
+* The "active" CDN is not stored — it's derived by the scope as the highest-priority entry in `cdnPriority` that still
+* has tracks after the constraints pre-pass. That makes failover a pure consequence of the (future) failed-CDN
+* constraint: when the primary's tracks are pruned during cooldown, the scope falls to the next CDN; when the primary
+* recovers, it snaps back. Content steering, when it lands, reorders `cdnPriority` (pathway priority as a sort key).
 *
-* Lifecycle: `'presentation-unresolved'` ↔ `'presentation-resolved'`, mirroring
-* `setupTrackSwitching`. The resolved state owns the signal; its entry-returned
-* cleanup clears it on exit (canonical cleanup-binds-to-setup per `reactors.md`).
+* Lifecycle: `'presentation-unresolved'` ↔ `'presentation-resolved'`, mirroring `setupTrackSwitching`. The resolved
+* state owns the signal; its entry-returned cleanup clears it on exit (canonical cleanup-binds-to-setup per
+* `reactors.md`).
 */
 const samePriority = (a, b) => !!a && a.length === b.length && a.every((cdn, i) => cdn === b[i]);
 /**
-* Manage `cdnPriority`: publish the manifest-ordered CDN list on src load, clear
-* on src unload.
+* Manage `cdnPriority`: publish the manifest-ordered CDN list on src load, clear on src unload.
 *
 * @example
-* const reactor = deriveCdnPriority.setup({ state });
+*   const reactor = deriveCdnPriority.setup({ state });
 */
 const deriveCdnPriority = defineBehavior({
 	stateKeys: ["presentation", "cdnPriority"],

package/dist/default/playback/behaviors/derive-cdn-priority.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive-cdn-priority.js","names":["getCdnId","defaultGetCdnId"],"sources":["../../../../src/playback/behaviors/derive-cdn-priority.ts"],"sourcesContent":["/**\n * **Session-level CDN priority.** While a presentation is resolved, owns the\n * `cdnPriority` signal: the distinct CDNs the source is served from (origin of\n * each track's URL), in manifest priority order — most-preferred first. Cleared\n * on src unload. The name mirrors HLS content steering's `PATHWAY-PRIORITY`.\n *\n * Redundant-stream sources (e.g. Mux's `?redundant_streams=true`) list the same\n * content on multiple hosts, so the candidate tracks already include one variant\n * per CDN. This behavior publishes *which* CDNs exist and their priority; the\n * `preferActiveCdn` scope rule in `track-switching` reads `cdnPriority` and\n * narrows each type's candidates to the first CDN with surviving tracks — so\n * video / audio / text all resolve from one host (the shared list is the\n * per-presentation coherence guarantee).\n *\n * The \"active\" CDN is not stored — it's derived by the scope as the\n * highest-priority entry in `cdnPriority` that still has tracks after the\n * constraints pre-pass. That makes failover a pure consequence of the (future)\n * failed-CDN constraint: when the primary's tracks are pruned during cooldown,\n * the scope falls to the next CDN; when the primary recovers, it snaps back.\n * Content steering, when it lands, reorders `cdnPriority` (pathway priority as a\n * sort key).\n *\n * Lifecycle: `'presentation-unresolved'` ↔ `'presentation-resolved'`, mirroring\n * `setupTrackSwitching`. The resolved state owns the signal; its entry-returned\n * cleanup clears it on exit (canonical cleanup-binds-to-setup per `reactors.md`).\n */\n\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';\nimport { getCdnId as defaultGetCdnId, type GetCdnId, getOrderedCdnIds } from '../../media/utils/cdn';\n\nexport interface DeriveCdnPriorityState {\n  presentation?: MaybeResolvedPresentation;\n  cdnPriority?: string[];\n}\n\nconst samePriority = (a: string[] | undefined, b: string[]): boolean =>\n  !!a && a.length === b.length && a.every((cdn, i) => cdn === b[i]);\n\n/**\n * Manage `cdnPriority`: publish the manifest-ordered CDN list on src load, clear\n * on src unload.\n *\n * @example\n * const reactor = deriveCdnPriority.setup({ state });\n */\nexport const deriveCdnPriority = defineBehavior({\n  stateKeys: ['presentation', 'cdnPriority'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: {\n      presentation: ReadonlySignal<DeriveCdnPriorityState['presentation']>;\n      cdnPriority: Signal<DeriveCdnPriorityState['cdnPriority']>;\n    };\n    config?: { getCdnId?: GetCdnId };\n  }) => {\n    const getCdnId = config.getCdnId ?? defaultGetCdnId;\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: the CDN priority list is valid for exactly\n          // 'presentation-resolved'. Clear fires on exit (src unload + destroy).\n          entry: () => () => state.cdnPriority.set(undefined),\n          effects: [\n            () => {\n              const presentation = state.presentation.get();\n              if (!isResolvedPresentation(presentation)) return;\n              const next = getOrderedCdnIds(presentation, getCdnId);\n              // Skip the write when the CDN set is unchanged — a live reload swaps\n              // in a new presentation object with the same hosts, and re-setting a\n              // fresh array would re-fire the scope for an identical result.\n              // `peek` reads without subscribing, so this never self-triggers.\n              if (!samePriority(peek(state.cdnPriority), next)) state.cdnPriority.set(next);\n            },\n          ],\n        },\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,gBAAgB,GAAyB,MAC7C,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,KAAK,MAAM,QAAQ,EAAE,EAAE;;;;;;;;AASlE,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,aAAa;CACzC,aAAa,CAAC;CACd,QAAQ,EACN,OACA,SAAS,CAAC,QAON;EACJ,MAAMA,aAAW,OAAO,YAAYC;EACpC,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;KAGvB,mBAAmB,MAAM,YAAY,IAAI,KAAA,CAAS;KAClD,SAAS,OACD;MACJ,MAAM,eAAe,MAAM,aAAa,IAAI;MAC5C,IAAI,CAAC,uBAAuB,YAAY,GAAG;MAC3C,MAAM,OAAO,iBAAiB,cAAcD,UAAQ;MAKpD,IAAI,CAAC,aAAa,KAAK,MAAM,WAAW,GAAG,IAAI,GAAG,MAAM,YAAY,IAAI,IAAI;KAC9E,CACF;IACF;GACF;EACF,CAAC;CACH;AACF,CAAC"}
+{"version":3,"file":"derive-cdn-priority.js","names":["getCdnId","defaultGetCdnId"],"sources":["../../../../src/playback/behaviors/derive-cdn-priority.ts"],"sourcesContent":["/**\n * **Session-level CDN priority.** While a presentation is resolved, owns the `cdnPriority` signal: the distinct CDNs\n * the source is served from (origin of each track's URL), in manifest priority order — most-preferred first. Cleared on\n * src unload. The name mirrors HLS content steering's `PATHWAY-PRIORITY`.\n *\n * Redundant-stream sources (e.g. Mux's `?redundant_streams=true`) list the same content on multiple hosts, so the\n * candidate tracks already include one variant per CDN. This behavior publishes _which_ CDNs exist and their priority;\n * the `preferActiveCdn` scope rule in `track-switching` reads `cdnPriority` and narrows each type's candidates to the\n * first CDN with surviving tracks — so video / audio / text all resolve from one host (the shared list is the\n * per-presentation coherence guarantee).\n *\n * The \"active\" CDN is not stored — it's derived by the scope as the highest-priority entry in `cdnPriority` that still\n * has tracks after the constraints pre-pass. That makes failover a pure consequence of the (future) failed-CDN\n * constraint: when the primary's tracks are pruned during cooldown, the scope falls to the next CDN; when the primary\n * recovers, it snaps back. Content steering, when it lands, reorders `cdnPriority` (pathway priority as a sort key).\n *\n * Lifecycle: `'presentation-unresolved'` ↔ `'presentation-resolved'`, mirroring `setupTrackSwitching`. The resolved\n * state owns the signal; its entry-returned cleanup clears it on exit (canonical cleanup-binds-to-setup per\n * `reactors.md`).\n */\n\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';\nimport { getCdnId as defaultGetCdnId, type GetCdnId, getOrderedCdnIds } from '../../media/utils/cdn';\n\nexport interface DeriveCdnPriorityState {\n  presentation?: MaybeResolvedPresentation;\n  cdnPriority?: string[];\n}\n\nconst samePriority = (a: string[] | undefined, b: string[]): boolean =>\n  !!a && a.length === b.length && a.every((cdn, i) => cdn === b[i]);\n\n/**\n * Manage `cdnPriority`: publish the manifest-ordered CDN list on src load, clear on src unload.\n *\n * @example\n *   const reactor = deriveCdnPriority.setup({ state });\n */\nexport const deriveCdnPriority = defineBehavior({\n  stateKeys: ['presentation', 'cdnPriority'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: {\n      presentation: ReadonlySignal<DeriveCdnPriorityState['presentation']>;\n      cdnPriority: Signal<DeriveCdnPriorityState['cdnPriority']>;\n    };\n    config?: { getCdnId?: GetCdnId };\n  }) => {\n    const getCdnId = config.getCdnId ?? defaultGetCdnId;\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: the CDN priority list is valid for exactly\n          // 'presentation-resolved'. Clear fires on exit (src unload + destroy).\n          entry: () => () => state.cdnPriority.set(undefined),\n          effects: [\n            () => {\n              const presentation = state.presentation.get();\n              if (!isResolvedPresentation(presentation)) return;\n\n              const next = getOrderedCdnIds(presentation, getCdnId);\n\n              // Skip the write when the CDN set is unchanged — a live reload swaps\n              // in a new presentation object with the same hosts, and re-setting a\n              // fresh array would re-fire the scope for an identical result.\n              // `peek` reads without subscribing, so this never self-triggers.\n              if (!samePriority(peek(state.cdnPriority), next)) state.cdnPriority.set(next);\n            },\n          ],\n        },\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAM,gBAAgB,GAAyB,MAC7C,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,KAAK,MAAM,QAAQ,EAAE,EAAE;;;;;;;AAQlE,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,aAAa;CACzC,aAAa,CAAC;CACd,QAAQ,EACN,OACA,SAAS,CAAC,QAON;EACJ,MAAMA,aAAW,OAAO,YAAYC;EACpC,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;KAGvB,mBAAmB,MAAM,YAAY,IAAI,KAAA,CAAS;KAClD,SAAS,OACD;MACJ,MAAM,eAAe,MAAM,aAAa,IAAI;MAC5C,IAAI,CAAC,uBAAuB,YAAY,GAAG;MAE3C,MAAM,OAAO,iBAAiB,cAAcD,UAAQ;MAMpD,IAAI,CAAC,aAAa,KAAK,MAAM,WAAW,GAAG,IAAI,GAAG,MAAM,YAAY,IAAI,IAAI;KAC9E,CACF;IACF;GACF;EACF,CAAC;CACH;AACF,CAAC"}