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

package/dist/dev/playback/behaviors/resolve-track.js

@@ -0,0 +1,141 @@
+import { computed, peek, update } from "../../core/signals/primitives.js";
+import { defineBehavior } from "../../core/composition/create-composition.js";
+import { RecurringRunner, Task, runOnce } from "../../core/tasks/task.js";
+import { createMachineReactor } from "../../core/reactors/create-machine-reactor.js";
+import { deriveStreamType, getMediaPlaylistMetadata, isResolvedPresentation, isResolvedTrack } from "../../media/types/index.js";
+import { applyContainerMimeType, findTrack, updateTrackInPresentation } from "../../media/utils/tracks.js";
+import { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../primitives/track-types.js";
+import { NON_FMP4_CONTAINER_MIMES, parseMediaPlaylist } from "../../media/hls/parse-media-playlist.js";
+import { emitError } from "./collect-errors.js";
+import { fetchResolvableText } from "../../network/fetch.js";
+import { failoverFetch } from "../primitives/failover-fetch.js";
+import { when } from "../../core/signals/when.js";
+//#region src/playback/behaviors/resolve-track.ts
+function setupTrackResolution({ state, config: { selectedKey, findTrackToResolve, fetchResolvableText: fetchResolvableText$1 = fetchResolvableText, gateFirstParse, reschedule, reportUnsupportedTrackConditions } }) {
+	const runner = new RecurringRunner(reschedule ?? runOnce);
+	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: () => () => runner.abortAll(),
+				effects: [() => {
+					const presentation = peek(state.presentation);
+					const trackId = state[selectedKey].get();
+					if (!presentation || !trackId) return;
+					const track = findTrackToResolve(presentation, trackId);
+					if (!track || isResolvedTrack(track) && Number.isFinite(track.duration)) return;
+					runner.schedule(new Task(async (signal) => {
+						const snapshot = peek(state.presentation);
+						const current = snapshot ? findTrackToResolve(snapshot, trackId) : void 0;
+						if (!current) throw new Error("resolve-track: selected track not found");
+						const text = await fetchResolvableText$1(current, { signal });
+						if (gateFirstParse && !isResolvedTrack(current)) {
+							const { selectedVideoTrackId, selectedAudioTrackId } = state;
+							await when(() => gateFirstParse(state.presentation.get(), {
+								selectedVideoTrackId: selectedVideoTrackId?.get(),
+								selectedAudioTrackId: selectedAudioTrackId?.get()
+							}, trackId), { signal });
+						}
+						const live = peek(state.presentation);
+						const previous = live ? findTrackToResolve(live, trackId) : void 0;
+						if (!previous) throw new Error("resolve-track: selected track not found");
+						const mediaTrack = parseMediaPlaylist(text, previous);
+						if (reportUnsupportedTrackConditions) for (const condition of reportUnsupportedTrackConditions(mediaTrack)) emitError(state, condition);
+						update(state.presentation, (current) => {
+							if (!isResolvedPresentation(current)) return current;
+							const patched = updateTrackInPresentation(current, mediaTrack);
+							return {
+								...NON_FMP4_CONTAINER_MIMES.has(mediaTrack.mimeType) ? applyContainerMimeType(patched, mediaTrack.type, mediaTrack.mimeType) : patched,
+								streamType: deriveStreamType(getMediaPlaylistMetadata(mediaTrack))
+							};
+						});
+						return mediaTrack;
+					}, { id: track.id })).catch(() => {});
+				}]
+			}
+		}
+	});
+}
+const VIDEO_TRACK_RESOLUTION_CONFIG = {
+	...VIDEO_TYPE_CONFIG,
+	findTrackToResolve: (presentation, trackId) => findTrack(presentation, "video", trackId)
+};
+const AUDIO_TRACK_RESOLUTION_CONFIG = {
+	...AUDIO_TYPE_CONFIG,
+	findTrackToResolve: (presentation, trackId) => findTrack(presentation, "audio", trackId)
+};
+const TEXT_TRACK_RESOLUTION_CONFIG = {
+	...TEXT_TYPE_CONFIG,
+	findTrackToResolve: (presentation, trackId) => findTrack(presentation, "text", trackId)
+};
+/**
+* Resolve unresolved video tracks. Schedules a fetch task whenever the
+* selected video track is partially resolved, parses the manifest, and
+* writes the resolved track back into `state.presentation`.
+*/
+const resolveVideoTrack = defineBehavior({
+	stateKeys: ["presentation", "selectedVideoTrackId"],
+	contextKeys: [],
+	setup: ({ state, config = {} }) => {
+		const trackConfig = {
+			...VIDEO_TRACK_RESOLUTION_CONFIG,
+			...config
+		};
+		return setupTrackResolution({
+			state,
+			config: {
+				...trackConfig,
+				fetchResolvableText: failoverFetch(fetchResolvableText, state, trackConfig)
+			}
+		});
+	}
+});
+/**
+* Resolve unresolved audio tracks. Same shape as `resolveVideoTrack`,
+* narrowed to audio.
+*/
+const resolveAudioTrack = defineBehavior({
+	stateKeys: ["presentation", "selectedAudioTrackId"],
+	contextKeys: [],
+	setup: ({ state, config = {} }) => {
+		const trackConfig = {
+			...AUDIO_TRACK_RESOLUTION_CONFIG,
+			...config
+		};
+		return setupTrackResolution({
+			state,
+			config: {
+				...trackConfig,
+				fetchResolvableText: failoverFetch(fetchResolvableText, state, trackConfig)
+			}
+		});
+	}
+});
+/**
+* Resolve unresolved text tracks. Same shape as `resolveVideoTrack`,
+* narrowed to text.
+*/
+const resolveTextTrack = defineBehavior({
+	stateKeys: ["presentation", "selectedTextTrackId"],
+	contextKeys: [],
+	setup: ({ state, config = {} }) => {
+		const trackConfig = {
+			...TEXT_TRACK_RESOLUTION_CONFIG,
+			...config
+		};
+		return setupTrackResolution({
+			state,
+			config: {
+				...trackConfig,
+				fetchResolvableText: failoverFetch(fetchResolvableText, state, trackConfig)
+			}
+		});
+	}
+});
+//#endregion
+export { resolveAudioTrack, resolveTextTrack, resolveVideoTrack };
+
+//# sourceMappingURL=resolve-track.js.map

package/dist/dev/playback/behaviors/resolve-track.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-track.js","names":["defaultFetchResolvableText","fetchResolvableText"],"sources":["../../../../src/playback/behaviors/resolve-track.ts"],"sourcesContent":["import { 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 { when } from '../../core/signals/when';\nimport { RecurringRunner, type Reschedule, runOnce, Task } from '../../core/tasks/task';\nimport { NON_FMP4_CONTAINER_MIMES, parseMediaPlaylist } from '../../media/hls/parse-media-playlist';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTrack, ResolvedTrack } from '../../media/types';\nimport { deriveStreamType, getMediaPlaylistMetadata, isResolvedPresentation, isResolvedTrack } from '../../media/types';\nimport type { GetCdnId } from '../../media/utils/cdn';\nimport { applyContainerMimeType, findTrack, updateTrackInPresentation } from '../../media/utils/tracks';\nimport { fetchResolvableText as defaultFetchResolvableText, type FetchText } from '../../network/fetch';\nimport { failoverFetch } from '../primitives/failover-fetch';\nimport type { GateFirstParse } from '../primitives/gate-first-parse';\nimport type { ReportUnsupportedTrackConditions } from '../primitives/report-track-conditions';\nimport { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../primitives/track-types';\nimport { type ErrorEmitterState, emitError } from './collect-errors';\n\n// ============================================================================\n// Specialization helper\n//\n// `setupTrackResolution` has the same shape as a Behavior `setup` function:\n// `({ state, config }) => cleanup`. Each `resolveXTrack` export below calls it\n// from inside its own `defineBehavior` setup, supplying its per-type config\n// inline. The orchestration — gate on a selection, short-circuit when the\n// track is already resolved or missing, schedule the fetch+parse, and patch\n// the resolved track back into `state.presentation` — is shared.\n// ============================================================================\n\n/**\n * State shape for track resolution. Uses `MaybeResolvedPresentation` so it\n * matches the engine's slot type; resolution narrows internally.\n */\nexport interface ResolveTrackState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  selectedTextTrackId?: string;\n  failedCdns?: string[];\n}\n\ntype SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId' | 'selectedTextTrackId';\n\ntype ResolveTrackStateMap<K extends SelectedTrackKey> = {\n  presentation: Signal<ResolveTrackState['presentation']>;\n} & { [P in K]: ReadonlySignal<ResolveTrackState[P]> };\n\n/**\n * Sibling-owned A/V selection signals, present at runtime iff a sibling\n * behavior owns them. Deliberately not in the typed slice / `stateKeys`\n * (declaring them would force every composition to carry both selections);\n * read only to build the injected first-parse gate's selection context.\n */\ntype SiblingSelectionSignals = {\n  selectedVideoTrackId?: ReadonlySignal<ResolveTrackState['selectedVideoTrackId']>;\n  selectedAudioTrackId?: ReadonlySignal<ResolveTrackState['selectedAudioTrackId']>;\n};\n\ninterface TrackResolutionConfig<K extends SelectedTrackKey> {\n  selectedKey: K;\n  findTrackToResolve: (\n    presentation: MaybeResolvedPresentation,\n    trackId: string\n  ) => PartiallyResolvedTrack | ResolvedTrack | undefined;\n  /** Fetch a track's media-playlist text — already failover-decorated by the behavior. */\n  fetchResolvableText?: FetchText;\n  /** Holds a track's first parse until its placement inputs settle (live anchor); absent → parse immediately. */\n  gateFirstParse?: GateFirstParse;\n  /** Live re-run policy for the `RecurringRunner`; absent → resolve once (VOD). */\n  reschedule?: Reschedule<ResolvedTrack>;\n  /**\n   * Report conditions found in the parsed playlist (see\n   * `primitives/report-track-conditions`); absent → report nothing.\n   */\n  reportUnsupportedTrackConditions?: ReportUnsupportedTrackConditions;\n}\n\n/**\n * Engine-config slice each `resolve*` behavior reads to build its failover-\n * decorated playlist fetch.\n */\ninterface ResolveTrackConfig {\n  /** CDN-id derivation for the failover trip; defaults to origin-based `getCdnId`. */\n  getCdnId?: GetCdnId;\n  /** First-parse placement gate (see `primitives/gate-first-parse`); absent → parse immediately. */\n  gateFirstParse?: GateFirstParse;\n  /** Live media-playlist re-run policy; absent → resolve once. */\n  reschedule?: Reschedule<ResolvedTrack>;\n  /** Playlist-derived condition reporting (see `primitives/report-track-conditions`). */\n  reportUnsupportedTrackConditions?: ReportUnsupportedTrackConditions;\n}\n\nfunction setupTrackResolution<K extends SelectedTrackKey>({\n  state,\n  config: {\n    selectedKey,\n    findTrackToResolve,\n    fetchResolvableText = defaultFetchResolvableText,\n    gateFirstParse,\n    reschedule,\n    reportUnsupportedTrackConditions,\n  },\n}: {\n  // Widened with the optional `errors` slot: reporting writes through it without\n  // the behavior declaring ownership, and no-ops when `collectErrors` isn't\n  // composed. Same contract as `failedCdns` / `failoverFetch`.\n  state: ResolveTrackStateMap<K> & ErrorEmitterState;\n  config: TrackResolutionConfig<K>;\n}) {\n  // Recurrence lives in the runner: with a `reschedule` (live) it re-runs the\n  // task until the policy stops; `runOnce` (VOD) runs it exactly once. Single-\n  // slot — a selection change re-schedules (abort-and-replace).\n  const runner = new RecurringRunner<ResolvedTrack>(reschedule ?? runOnce);\n\n  // Reactor states model the FSM the previous effect-based body was\n  // hand-rolling. 'presentation-resolved' is entered when the\n  // presentation is fully parsed (has a Ham id + selectionSets); leaving\n  // it (presentation cleared or reset to an unresolved value) aborts all\n  // in-flight tasks via the entry-cleanup. Most URL changes go through\n  // 'presentation-unresolved' naturally (set undefined → set new partial\n  // → re-parse), so the common case is covered by state-exit alone; the\n  // task body's commit-time id check covers the pathological\n  // resolved→resolved-without-unresolved transition.\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        // `entry` runs on state entry; the function it returns is the\n        // state-exit cleanup. Returning `() => runner.abortAll()` binds\n        // abort-of-in-flight-resolutions to leaving 'presentation-resolved'\n        // (presentation cleared/reset, or behavior destroyed) —\n        // source-change cancellation expressed structurally through the\n        // state machine.\n        entry: () => () => runner.abortAll(),\n        effects: [\n          () => {\n            // The reactor's state transitions handle relevant presentation\n            // changes (presentation-resolved ↔ presentation-unresolved);\n            // within 'presentation-resolved' we peek (untracked read) so\n            // internal updates (segments added by sibling tasks, or by this\n            // behavior's own reload cycles) don't re-fire the effect.\n            const presentation = peek(state.presentation);\n            const trackId = state[selectedKey].get();\n            if (!presentation || !trackId) return;\n\n            const track = findTrackToResolve(presentation, trackId);\n            // Skip a complete or missing track; a resolved-but-incomplete (live)\n            // window still reloads — its window may have slid past the playhead.\n            if (!track || (isResolvedTrack(track) && Number.isFinite(track.duration))) return;\n\n            // Abort (selection/source change) settles quietly; a genuine resolve\n            // failure rejects — swallowed for now (TODO: surface to state).\n            const scheduled = runner.schedule(\n              // NOTE: This can/maybe will be pulled into a per-use case factory (e.g. something like createResolveTrackTask(track, context, config)),\n              // likely eventually passed down via config or a new \"definitions\" argument (CJP).\n              //\n              // Re-runs (clones) on each reload, so the body re-reads the live\n              // snapshot (via `trackId`) rather than capturing the gate-time\n              // `track` — a reload carries the prior window's timeline forward.\n              new Task(\n                async (signal) => {\n                  const snapshot = peek(state.presentation);\n                  const current = snapshot ? findTrackToResolve(snapshot, trackId) : undefined;\n                  if (!current) throw new Error('resolve-track: selected track not found');\n\n                  // `fetchResolvableText` is the behavior's failover-decorated\n                  // fetch: it trips the CDN on a failed fetch (network error or\n                  // non-OK status). A parse failure is a content issue, not a\n                  // CDN-availability one, so it doesn't trip. The run-time\n                  // `current` supplies only the playlist URL (stable across the\n                  // fetch).\n                  const text = await fetchResolvableText(current, { signal });\n\n                  // Hold placement — never the fetch — until this track's\n                  // first-parse placement inputs settle (for live, the\n                  // wall-clock anchor; see `primitives/gate-first-parse`).\n                  // First parses only — a reload's window is already on the\n                  // established timeline. Aborting rejects the wait, so a\n                  // source change can't strand a gated task.\n                  if (gateFirstParse && !isResolvedTrack(current)) {\n                    const { selectedVideoTrackId, selectedAudioTrackId } = state as SiblingSelectionSignals;\n                    await when(\n                      () =>\n                        gateFirstParse(\n                          state.presentation.get(),\n                          {\n                            selectedVideoTrackId: selectedVideoTrackId?.get(),\n                            selectedAudioTrackId: selectedAudioTrackId?.get(),\n                          },\n                          trackId\n                        ),\n                      { signal }\n                    );\n                  }\n\n                  // Re-read `previous` after the awaits: a concurrent write\n                  // during them — notably the establishment reactor stamping\n                  // the anchor `startDate` onto this track's shell — must feed\n                  // the parse, not be clobbered (anchoring is establish-once;\n                  // parsing the pre-fetch snapshot would strand the track off\n                  // the anchor for good). Correctness rests on a\n                  // run-to-completion invariant: NOTHING may yield (await)\n                  // between this re-read and the write below, so no writer can\n                  // interleave. `parseMediaPlaylist` is synchronous — keep it\n                  // that way, or move the read into the updater.\n                  const live = peek(state.presentation);\n                  const previous = live ? findTrackToResolve(live, trackId) : undefined;\n                  if (!previous) throw new Error('resolve-track: selected track not found');\n                  const mediaTrack = parseMediaPlaylist(text, previous);\n\n                  // Report what the parse revealed about this rendition, before\n                  // committing it. Causes only — one unplayable rendition doesn't\n                  // make the source unplayable, so the verdict stays with\n                  // track-switching's empty-candidate branch.\n                  if (reportUnsupportedTrackConditions) {\n                    for (const condition of reportUnsupportedTrackConditions(mediaTrack as ResolvedTrack)) {\n                      emitError(state, condition);\n                    }\n                  }\n\n                  // Updater handles undefined inputs by returning current\n                  // unchanged; isResolvedPresentation narrows for the patch.\n                  // State-exit on resolving→unresolved fires runner.abortAll\n                  // before any URL change settles, and per the Fetch spec the\n                  // signal abort cancels in-flight body reads — so by the\n                  // time we reach this point the presentation we resolved\n                  // against is the live one.\n                  update(state.presentation, (current) => {\n                    if (!isResolvedPresentation(current)) return current;\n                    const patched = updateTrackInPresentation(current, mediaTrack);\n                    // Container is uniform within a type (an ABR ladder shares\n                    // its container), so a detected non-fMP4 rendition (TS,\n                    // raw AAC) implies every rendition of *this* type matches —\n                    // relabel them all from one resolved playlist instead of\n                    // fetching each. Scoped to this track's own type: never cross\n                    // audio↔video (mixed-container sources exist, e.g. muxed-TS\n                    // video + raw-.aac audio), which also keeps per-type\n                    // resolutions' writes disjoint (no race).\n                    const relabeled = NON_FMP4_CONTAINER_MIMES.has(mediaTrack.mimeType)\n                      ? applyContainerMimeType(patched, mediaTrack.type, mediaTrack.mimeType)\n                      : patched;\n                    // Stream nature (live vs on-demand), rewritten from whichever\n                    // track just parsed — every type's resolve and every live\n                    // reload takes this path. Idempotent in practice rather than\n                    // by construction: `PLAYLIST-TYPE` is a per-source constant\n                    // that a source's renditions agree on, so each write lands\n                    // the same value. Renditions that disagreed would make the\n                    // winner resolve-order-dependent.\n                    return { ...relabeled, streamType: deriveStreamType(getMediaPlaylistMetadata(mediaTrack)) };\n                  });\n                  return mediaTrack;\n                },\n                { id: track.id }\n              )\n            );\n            scheduled.catch(() => {});\n          },\n        ],\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Per-helper-per-type configs — defaults that variants spread engine config over\n// ============================================================================\n\nconst VIDEO_TRACK_RESOLUTION_CONFIG = {\n  ...VIDEO_TYPE_CONFIG,\n  findTrackToResolve: (presentation: MaybeResolvedPresentation, trackId: string) =>\n    findTrack(presentation, 'video', trackId),\n} as const;\n\nconst AUDIO_TRACK_RESOLUTION_CONFIG = {\n  ...AUDIO_TYPE_CONFIG,\n  findTrackToResolve: (presentation: MaybeResolvedPresentation, trackId: string) =>\n    findTrack(presentation, 'audio', trackId),\n} as const;\n\nconst TEXT_TRACK_RESOLUTION_CONFIG = {\n  ...TEXT_TYPE_CONFIG,\n  findTrackToResolve: (presentation: MaybeResolvedPresentation, trackId: string) =>\n    findTrack(presentation, 'text', trackId),\n} as const;\n\n// ============================================================================\n// Specialized exports — one per track type\n// ============================================================================\n\n/**\n * Resolve unresolved video tracks. Schedules a fetch task whenever the\n * selected video track is partially resolved, parses the manifest, and\n * writes the resolved track back into `state.presentation`.\n */\nexport const resolveVideoTrack = defineBehavior({\n  stateKeys: ['presentation', 'selectedVideoTrackId'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: ResolveTrackStateMap<'selectedVideoTrackId'>;\n    config?: ResolveTrackConfig;\n  }) => {\n    // Engine `config` layers over the per-type defaults (mirrors the other\n    // per-type variants, see track-types.ts); `failoverFetch` reads its\n    // `selectedKey` + `getCdnId` from the merged result. `fetchResolvableText`\n    // is then placed AFTER the spread so the failover-decorated fetch wins —\n    // unlike segments, playlists expose no overridable per-type fetch.\n    const trackConfig = { ...VIDEO_TRACK_RESOLUTION_CONFIG, ...config };\n    return setupTrackResolution({\n      state,\n      config: { ...trackConfig, fetchResolvableText: failoverFetch(defaultFetchResolvableText, state, trackConfig) },\n    });\n  },\n});\n\n/**\n * Resolve unresolved audio tracks. Same shape as `resolveVideoTrack`,\n * narrowed to audio.\n */\nexport const resolveAudioTrack = defineBehavior({\n  stateKeys: ['presentation', 'selectedAudioTrackId'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: ResolveTrackStateMap<'selectedAudioTrackId'>;\n    config?: ResolveTrackConfig;\n  }) => {\n    // Key order is load-bearing — see resolveVideoTrack.\n    const trackConfig = { ...AUDIO_TRACK_RESOLUTION_CONFIG, ...config };\n    return setupTrackResolution({\n      state,\n      config: { ...trackConfig, fetchResolvableText: failoverFetch(defaultFetchResolvableText, state, trackConfig) },\n    });\n  },\n});\n\n/**\n * Resolve unresolved text tracks. Same shape as `resolveVideoTrack`,\n * narrowed to text.\n */\nexport const resolveTextTrack = defineBehavior({\n  stateKeys: ['presentation', 'selectedTextTrackId'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: ResolveTrackStateMap<'selectedTextTrackId'>;\n    config?: ResolveTrackConfig;\n  }) => {\n    // Key order is load-bearing — see resolveVideoTrack.\n    const trackConfig = { ...TEXT_TRACK_RESOLUTION_CONFIG, ...config };\n    return setupTrackResolution({\n      state,\n      config: { ...trackConfig, fetchResolvableText: failoverFetch(defaultFetchResolvableText, state, trackConfig) },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;AA2FA,SAAS,qBAAiD,EACxD,OACA,QAAQ,EACN,aACA,oBACA,qBAAA,wBAAsBA,qBACtB,gBACA,YACA,sCAQD;CAID,MAAM,SAAS,IAAI,gBAA+B,cAAc,OAAO;CAWvE,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,IAAI,CAAC,IAC1C,0BACA,yBACP;CAEA,OAAO,qBAAqB;EAC1B,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,2BAA2B,CAAC;GAC5B,yBAAyB;IAOvB,mBAAmB,OAAO,SAAS;IACnC,SAAS,OACD;KAMJ,MAAM,eAAe,KAAK,MAAM,YAAY;KAC5C,MAAM,UAAU,MAAM,YAAY,CAAC,IAAI;KACvC,IAAI,CAAC,gBAAgB,CAAC,SAAS;KAE/B,MAAM,QAAQ,mBAAmB,cAAc,OAAO;KAGtD,IAAI,CAAC,SAAU,gBAAgB,KAAK,KAAK,OAAO,SAAS,MAAM,QAAQ,GAAI;KA2G3E,OAvGyB,SAOvB,IAAI,KACF,OAAO,WAAW;MAChB,MAAM,WAAW,KAAK,MAAM,YAAY;MACxC,MAAM,UAAU,WAAW,mBAAmB,UAAU,OAAO,IAAI,KAAA;MACnE,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,yCAAyC;MAQvE,MAAM,OAAO,MAAMC,sBAAoB,SAAS,EAAE,OAAO,CAAC;MAQ1D,IAAI,kBAAkB,CAAC,gBAAgB,OAAO,GAAG;OAC/C,MAAM,EAAE,sBAAsB,yBAAyB;OACvD,MAAM,WAEF,eACE,MAAM,aAAa,IAAI,GACvB;QACE,sBAAsB,sBAAsB,IAAI;QAChD,sBAAsB,sBAAsB,IAAI;OAClD,GACA,OACF,GACF,EAAE,OAAO,CACX;MACF;MAYA,MAAM,OAAO,KAAK,MAAM,YAAY;MACpC,MAAM,WAAW,OAAO,mBAAmB,MAAM,OAAO,IAAI,KAAA;MAC5D,IAAI,CAAC,UAAU,MAAM,IAAI,MAAM,yCAAyC;MACxE,MAAM,aAAa,mBAAmB,MAAM,QAAQ;MAMpD,IAAI,kCACF,KAAK,MAAM,aAAa,iCAAiC,UAA2B,GAClF,UAAU,OAAO,SAAS;MAW9B,OAAO,MAAM,eAAe,YAAY;OACtC,IAAI,CAAC,uBAAuB,OAAO,GAAG,OAAO;OAC7C,MAAM,UAAU,0BAA0B,SAAS,UAAU;OAmB7D,OAAO;QAAE,GAVS,yBAAyB,IAAI,WAAW,QAAQ,IAC9D,uBAAuB,SAAS,WAAW,MAAM,WAAW,QAAQ,IACpE;QAQmB,YAAY,iBAAiB,yBAAyB,UAAU,CAAC;OAAE;MAC5F,CAAC;MACD,OAAO;KACT,GACA,EAAE,IAAI,MAAM,GAAG,CACjB,CAEM,CAAC,CAAC,YAAY,CAAC,CAAC;IAC1B,CACF;GACF;EACF;CACF,CAAC;AACH;AAMA,MAAM,gCAAgC;CACpC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,SAAS,OAAO;AAC5C;AAEA,MAAM,gCAAgC;CACpC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,SAAS,OAAO;AAC5C;AAEA,MAAM,+BAA+B;CACnC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,QAAQ,OAAO;AAC3C;;;;;;AAWA,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,CAAC;CACd,QAAQ,EACN,OACA,SAAS,CAAC,QAIN;EAMJ,MAAM,cAAc;GAAE,GAAG;GAA+B,GAAG;EAAO;EAClE,OAAO,qBAAqB;GAC1B;GACA,QAAQ;IAAE,GAAG;IAAa,qBAAqB,cAAcD,qBAA4B,OAAO,WAAW;GAAE;EAC/G,CAAC;CACH;AACF,CAAC;;;;;AAMD,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,CAAC;CACd,QAAQ,EACN,OACA,SAAS,CAAC,QAIN;EAEJ,MAAM,cAAc;GAAE,GAAG;GAA+B,GAAG;EAAO;EAClE,OAAO,qBAAqB;GAC1B;GACA,QAAQ;IAAE,GAAG;IAAa,qBAAqB,cAAcA,qBAA4B,OAAO,WAAW;GAAE;EAC/G,CAAC;CACH;AACF,CAAC;;;;;AAMD,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,gBAAgB,qBAAqB;CACjD,aAAa,CAAC;CACd,QAAQ,EACN,OACA,SAAS,CAAC,QAIN;EAEJ,MAAM,cAAc;GAAE,GAAG;GAA8B,GAAG;EAAO;EACjE,OAAO,qBAAqB;GAC1B;GACA,QAAQ;IAAE,GAAG;IAAa,qBAAqB,cAAcA,qBAA4B,OAAO,WAAW;GAAE;EAC/G,CAAC;CACH;AACF,CAAC"}

package/dist/dev/playback/behaviors/select-tracks.d.ts

@@ -0,0 +1,72 @@
+import "../../core/signals/primitives.js";
+import "../../index.js";
+import { CapabilityConstraintConfig, SelectionRule } from "../primitives/selection-rules.js";
+//#region src/playback/behaviors/select-tracks.d.ts
+/** A selection rule over this behavior's candidate tracks. */
+type SelectTrackRule<Config> = SelectionRule<SelectableTrack, unknown, unknown, Config | undefined>;
+/** What a rule here needs off a candidate: the id it may become the pick by. */
+type SelectableTrack = {
+  id: string;
+};
+/**
+ * Order the candidates by resolution, largest first, with bandwidth breaking ties
+ * between renditions of identical dimensions. The background-video default — that
+ * variant pins one rendition for the session, and absent a cap the largest is the
+ * head.
+ *
+ * A ranker, so it reorders rather than narrowing: the chain's pick is the head of
+ * what it returns, which means ranking never has to collapse to one track. Belongs
+ * last in a chain — a sort only reorders what survived the filters ahead of it, and
+ * leaving it last is what lets `applyRules` early-bail before it runs.
+ *
+ * Exported because it is a *rule*, not a variant's private policy: the same one
+ * composes into `switchVideoTrack`'s chain when a ranker is wanted there.
+ */
+declare const preferHighestResolution: SelectTrackRule<unknown>;
+/**
+ * Narrow to the renditions that fit the screen, by pixel area — the screen-size
+ * cap from `internal/design/spf/features/rendition-selection-caps.md`, as a scope
+ * (soft filter) rather than a constraint: an over-cap rendition is wasteful, not
+ * unplayable, so nothing here may make a source unplayable.
+ *
+ * Narrows only — it neither orders the survivors nor resolves the case where none
+ * survive, because `applyRules` owns both. So it needs a ranker behind it to pick
+ * within the cap: `[screenResolutionCap, preferHighestResolution]` yields the
+ * largest rendition that fits. Composed *last*, the pick would instead be whichever
+ * fitting rendition the manifest happened to list first.
+ *
+ * Reading `state.screenResolution` through its signal is what subscribes a
+ * re-evaluating chain (`switchVideoTrack`) to screen changes; `selectVideoTrack`
+ * pins the first answer instead, by design.
+ *
+ * Compares areas rather than matching a `"1080p"`-style tier because a tier only
+ * describes a rendition once you assume its aspect ratio — the assumption that
+ * mis-measures an anamorphic ladder. See `media/dom/screen.ts`.
+ *
+ * Three ways the cap ends up not applying, all of them fall-through:
+ *
+ * - **No `screenResolution` signal at all**, because the composition omits
+ *   `trackScreenResolution`. So composing the cap without its signal source is
+ *   inert rather than broken.
+ * - **A `screenResolution` of `undefined`**, meaning no screen to read. "Unknown"
+ *   has to mean "don't cap": treating it as an area of zero would pin every source
+ *   to its smallest rendition on exactly the environments we know least about.
+ * - **No rendition fits**, on a screen smaller than the whole ladder. `applyRules`
+ *   skips the empty result and the chain proceeds unnarrowed, so the ranker behind
+ *   the cap decides — for `preferHighestResolution`, the largest rendition. A floor
+ *   is the fix if that ever matters (`rendition-selection-caps.md` carries one), not
+ *   a special case here.
+ */
+declare const screenResolutionCap: SelectTrackRule<unknown>;
+/**
+ * Config for `selectVideoTrack`. Pass `rules` to replace the selection chain, or
+ * `constraints` to replace the capability pre-pass; otherwise the chain is empty
+ * and the first playable candidate is the pick.
+ */
+interface SelectVideoTrackConfig extends CapabilityConstraintConfig {
+  constraints?: readonly SelectTrackRule<SelectVideoTrackConfig>[];
+  rules?: readonly SelectTrackRule<SelectVideoTrackConfig>[];
+}
+//#endregion
+export { SelectTrackRule, SelectVideoTrackConfig, preferHighestResolution, screenResolutionCap };
+//# sourceMappingURL=select-tracks.d.ts.map

package/dist/dev/playback/behaviors/select-tracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-tracks.d.ts","names":[],"sources":["../../../../src/playback/behaviors/select-tracks.ts"],"mappings":";;;;;KA8FY,gBAAgB,UAAU,cAAc,mCAAmC;;KAGlF;EAAoB;;;;;;;;;;;;;;;;cA+JZ,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCzB,qBAAqB;;;;;;UAgBjB,+BAA+B;EAC9C,uBAAuB,gBAAgB;EACvC,iBAAiB,gBAAgB"}

package/dist/dev/playback/behaviors/select-tracks.js

@@ -0,0 +1,216 @@
+import { computed, peek } 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";
+import { getTracksByType } from "../../media/utils/tracks.js";
+import { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../primitives/track-types.js";
+import { byDescendingResolution, pickAudioTrackFromTracks, tracksUnderPixelArea } from "../../media/primitives/select-tracks.js";
+import { applyConstraints, applyRules, excludeUnplayableTracks, sameCandidateSet } from "../primitives/selection-rules.js";
+//#region src/playback/behaviors/select-tracks.ts
+/**
+* **Default audio/video track selection on src load / unselect on src unload.**
+* When a presentation is resolved, sets `selectedVideoTrackId` /
+* `selectedAudioTrackId` from a per-type default rule chain if no selection
+* already exists. When the presentation is unset/reset (transitions back to unresolved),
+* clears the selection so a stale id from the previous source doesn't persist.
+*
+* Lifecycle-driven: the pick fires once per transition, and nothing re-picks —
+* that is what separates these from the `switch*` variants. External writes (user
+* picks, ABR, programmatic filter-driven re-picks) are left alone, including a
+* write naming a track the manifest never offered.
+*
+* The one thing policed between transitions is a pick the *constraints* turn
+* against: a rendition's container and encryption are only known once its media
+* playlist resolves, which is after the pick was made, so a selection that becomes
+* unplayable is dropped. Dropped, never moved — re-picking is exactly the behavior
+* `switchVideoTrack` exists to provide. Dropping reports nothing on its own, since
+* whatever made the pick unplayable already reported its own, more specific cause.
+*
+* Selection runs the same rule model `switchVideoTrack` does — a hard
+* `constraints` pre-pass, then an ordered `rules` chain, with the pick as the
+* head (see `internal/design/spf/track-switching-model.md`). What differs is
+* reactivity, not the rules: this evaluates the chain once on resolve and pins
+* the result, where `switchVideoTrack` re-evaluates inside an effect so its rules
+* subscribe to bandwidth and user selection. A rule written for one therefore
+* composes into the other unchanged.
+*
+* Both are config-driven, each per-type export wiring a sensible default: audio's
+* three-tier language policy, and for video the *empty* chain — with nothing
+* narrowing or reordering, the head is the first candidate. The behavior's
+* `config` is forwarded to the rules, so options like `preferredAudioLanguage`
+* reach them without an intermediate layer.
+*
+* Note a rule can only pick among real candidates, where the picker it replaced
+* could return any id at all. An id absent from the manifest was never
+* selectable, so that narrowing is the point rather than a limitation.
+*
+* Compose `selectVideoTrack` for the simple "pick a default video track"
+* behavior, or `switchVideoTrack` (`./track-switching.ts`) for the
+* ABR-driven variant. Compose `selectAudioTrack` for the simple default
+* pick, or `switchAudioTrack` (`./track-switching.ts`) for the
+* filter-reactive + mid-stream-flush slot-owner variant — when audio-abr
+* lands, `switchAudioTrack` extends into `switchAudioQuality`. Compose
+* only one per type — they're alternatives, not stackable (each writes
+* the same `selected*TrackId` slot). The simple variants tree-shake out
+* the heavier machinery (bandwidth estimator, quality selection, flush
+* orchestration).
+*
+* Text selection has no simple variant here — it's owned by `switchTextTrack`
+* (`./track-switching.ts`), which resolves standing `userTextTrackSelection`
+* intent against the constrained, CDN-scoped renditions.
+*/
+function setupTrackSelection({ state, config: { selectedKey, trackType, constraints, rules, ruleConfig } }) {
+	const derivedStateSignal = computed(() => isResolvedPresentation(state.presentation.get()) ? "presentation-resolved" : "presentation-unresolved");
+	const deps = {
+		state,
+		config: ruleConfig
+	};
+	const candidateSet = computed(() => {
+		const presentation = state.presentation.get();
+		if (!isResolvedPresentation(presentation)) return [];
+		return applyConstraints(constraints, getTracksByType(presentation, trackType), deps);
+	}, { equals: sameCandidateSet });
+	return createMachineReactor({
+		initial: "presentation-unresolved",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"presentation-unresolved": {},
+			"presentation-resolved": {
+				entry: () => {
+					if (!state[selectedKey].get()) {
+						const id = applyRules(rules, peek(candidateSet), deps)[0]?.id;
+						if (id) state[selectedKey].set(id);
+					}
+					return () => state[selectedKey].set(void 0);
+				},
+				effects: [() => {
+					const selectedId = peek(state[selectedKey]);
+					if (!selectedId) return;
+					if (candidateSet.get().some((track) => track.id === selectedId)) return;
+					const presentation = peek(state.presentation);
+					if (isResolvedPresentation(presentation) && getTracksByType(presentation, trackType).some((track) => track.id === selectedId)) state[selectedKey].set(void 0);
+				}]
+			}
+		}
+	});
+}
+/** Default video chain: none. The first candidate is the pick. */
+const DEFAULT_VIDEO_RULES = [];
+/**
+* Default audio chain: the three-tier policy (`preferredAudioLanguage` →
+* `DEFAULT=YES` → first) as a single narrowing rule. Returning `[]` when nothing
+* is picked lets `applyRules` fall through to the unnarrowed candidates, so the
+* head stays the first track — the same last tier the policy itself ends on.
+*/
+const preferAudioPolicy = (tracks, { config }) => {
+	const id = pickAudioTrackFromTracks(tracks, config);
+	const pick = tracks.find((track) => track.id === id);
+	return pick ? [pick] : [];
+};
+const DEFAULT_AUDIO_RULES = [preferAudioPolicy];
+/**
+* Order the candidates by resolution, largest first, with bandwidth breaking ties
+* between renditions of identical dimensions. The background-video default — that
+* variant pins one rendition for the session, and absent a cap the largest is the
+* head.
+*
+* A ranker, so it reorders rather than narrowing: the chain's pick is the head of
+* what it returns, which means ranking never has to collapse to one track. Belongs
+* last in a chain — a sort only reorders what survived the filters ahead of it, and
+* leaving it last is what lets `applyRules` early-bail before it runs.
+*
+* Exported because it is a *rule*, not a variant's private policy: the same one
+* composes into `switchVideoTrack`'s chain when a ranker is wanted there.
+*/
+const preferHighestResolution = (tracks) => [...tracks].sort(byDescendingResolution);
+/**
+* Narrow to the renditions that fit the screen, by pixel area — the screen-size
+* cap from `internal/design/spf/features/rendition-selection-caps.md`, as a scope
+* (soft filter) rather than a constraint: an over-cap rendition is wasteful, not
+* unplayable, so nothing here may make a source unplayable.
+*
+* Narrows only — it neither orders the survivors nor resolves the case where none
+* survive, because `applyRules` owns both. So it needs a ranker behind it to pick
+* within the cap: `[screenResolutionCap, preferHighestResolution]` yields the
+* largest rendition that fits. Composed *last*, the pick would instead be whichever
+* fitting rendition the manifest happened to list first.
+*
+* Reading `state.screenResolution` through its signal is what subscribes a
+* re-evaluating chain (`switchVideoTrack`) to screen changes; `selectVideoTrack`
+* pins the first answer instead, by design.
+*
+* Compares areas rather than matching a `"1080p"`-style tier because a tier only
+* describes a rendition once you assume its aspect ratio — the assumption that
+* mis-measures an anamorphic ladder. See `media/dom/screen.ts`.
+*
+* Three ways the cap ends up not applying, all of them fall-through:
+*
+* - **No `screenResolution` signal at all**, because the composition omits
+*   `trackScreenResolution`. So composing the cap without its signal source is
+*   inert rather than broken.
+* - **A `screenResolution` of `undefined`**, meaning no screen to read. "Unknown"
+*   has to mean "don't cap": treating it as an area of zero would pin every source
+*   to its smallest rendition on exactly the environments we know least about.
+* - **No rendition fits**, on a screen smaller than the whole ladder. `applyRules`
+*   skips the empty result and the chain proceeds unnarrowed, so the ranker behind
+*   the cap decides — for `preferHighestResolution`, the largest rendition. A floor
+*   is the fix if that ever matters (`rendition-selection-caps.md` carries one), not
+*   a special case here.
+*/
+const screenResolutionCap = (tracks, { state }) => {
+	const screenResolution = state?.screenResolution?.get();
+	if (!screenResolution) return [];
+	return tracksUnderPixelArea(tracks, screenResolution.width * screenResolution.height);
+};
+/**
+* Default video constraints: the capability pre-pass alone. No
+* `excludeFailedCdns` — this variant's compositions run no failover monitor, so
+* `failedCdns` has no writer and the constraint would always pass through.
+*/
+const DEFAULT_VIDEO_CONSTRAINTS = [excludeUnplayableTracks];
+/**
+* Select a video track when a presentation loads. Clears the selection on
+* src unload.
+*
+* This is the simple, non-ABR counterpart to `switchVideoTrack` — compose
+* one or the other, not both (both write `selectedVideoTrackId`). Composing
+* `selectVideoTrack` alone tree-shakes out the ABR code path
+* (bandwidth-estimator, quality-selection); use it for sources without
+* meaningful quality variants, test setups, or players that intentionally
+* pin a quality.
+*
+* @example
+* const reactor = selectVideoTrack.setup({ state });
+*/
+const selectVideoTrack = defineBehavior({
+	stateKeys: ["presentation", "selectedVideoTrackId"],
+	contextKeys: [],
+	setup: ({ state, config }) => setupTrackSelection({
+		state,
+		config: {
+			selectedKey: VIDEO_TYPE_CONFIG.selectedKey,
+			trackType: "video",
+			constraints: config?.constraints ?? DEFAULT_VIDEO_CONSTRAINTS,
+			rules: config?.rules ?? DEFAULT_VIDEO_RULES,
+			ruleConfig: config
+		}
+	})
+});
+defineBehavior({
+	stateKeys: ["presentation", "selectedAudioTrackId"],
+	contextKeys: [],
+	setup: ({ state, config }) => setupTrackSelection({
+		state,
+		config: {
+			selectedKey: AUDIO_TYPE_CONFIG.selectedKey,
+			trackType: "audio",
+			constraints: config?.constraints ?? [],
+			rules: config?.rules ?? DEFAULT_AUDIO_RULES,
+			ruleConfig: config
+		}
+	})
+});
+//#endregion
+export { preferHighestResolution, screenResolutionCap, selectVideoTrack };
+
+//# sourceMappingURL=select-tracks.js.map

package/dist/dev/playback/behaviors/select-tracks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-tracks.js","names":[],"sources":["../../../../src/playback/behaviors/select-tracks.ts"],"sourcesContent":["/**\n * **Default audio/video track selection on src load / unselect on src unload.**\n * When a presentation is resolved, sets `selectedVideoTrackId` /\n * `selectedAudioTrackId` from a per-type default rule chain if no selection\n * already exists. When the presentation is unset/reset (transitions back to unresolved),\n * clears the selection so a stale id from the previous source doesn't persist.\n *\n * Lifecycle-driven: the pick fires once per transition, and nothing re-picks —\n * that is what separates these from the `switch*` variants. External writes (user\n * picks, ABR, programmatic filter-driven re-picks) are left alone, including a\n * write naming a track the manifest never offered.\n *\n * The one thing policed between transitions is a pick the *constraints* turn\n * against: a rendition's container and encryption are only known once its media\n * playlist resolves, which is after the pick was made, so a selection that becomes\n * unplayable is dropped. Dropped, never moved — re-picking is exactly the behavior\n * `switchVideoTrack` exists to provide. Dropping reports nothing on its own, since\n * whatever made the pick unplayable already reported its own, more specific cause.\n *\n * Selection runs the same rule model `switchVideoTrack` does — a hard\n * `constraints` pre-pass, then an ordered `rules` chain, with the pick as the\n * head (see `internal/design/spf/track-switching-model.md`). What differs is\n * reactivity, not the rules: this evaluates the chain once on resolve and pins\n * the result, where `switchVideoTrack` re-evaluates inside an effect so its rules\n * subscribe to bandwidth and user selection. A rule written for one therefore\n * composes into the other unchanged.\n *\n * Both are config-driven, each per-type export wiring a sensible default: audio's\n * three-tier language policy, and for video the *empty* chain — with nothing\n * narrowing or reordering, the head is the first candidate. The behavior's\n * `config` is forwarded to the rules, so options like `preferredAudioLanguage`\n * reach them without an intermediate layer.\n *\n * Note a rule can only pick among real candidates, where the picker it replaced\n * could return any id at all. An id absent from the manifest was never\n * selectable, so that narrowing is the point rather than a limitation.\n *\n * Compose `selectVideoTrack` for the simple \"pick a default video track\"\n * behavior, or `switchVideoTrack` (`./track-switching.ts`) for the\n * ABR-driven variant. Compose `selectAudioTrack` for the simple default\n * pick, or `switchAudioTrack` (`./track-switching.ts`) for the\n * filter-reactive + mid-stream-flush slot-owner variant — when audio-abr\n * lands, `switchAudioTrack` extends into `switchAudioQuality`. Compose\n * only one per type — they're alternatives, not stackable (each writes\n * the same `selected*TrackId` slot). The simple variants tree-shake out\n * the heavier machinery (bandwidth estimator, quality selection, flush\n * orchestration).\n *\n * Text selection has no simple variant here — it's owned by `switchTextTrack`\n * (`./track-switching.ts`), which resolves standing `userTextTrackSelection`\n * intent against the constrained, CDN-scoped renditions.\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 type { Resolution } from '../../media/primitives/resolution';\nimport {\n  type AudioSelectionConfig,\n  byDescendingResolution,\n  pickAudioTrackFromTracks,\n  type TrackSelectionState,\n  tracksUnderPixelArea,\n} from '../../media/primitives/select-tracks';\nimport { isResolvedPresentation, type TrackType } from '../../media/types';\nimport { getTracksByType } from '../../media/utils/tracks';\nimport {\n  applyConstraints,\n  applyRules,\n  type CapabilityConstraintConfig,\n  excludeUnplayableTracks,\n  type SelectionRule,\n  sameCandidateSet,\n} from '../primitives/selection-rules';\nimport { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../primitives/track-types';\n\n// ============================================================================\n// Specialization helper\n//\n// `setupTrackSelection` has the same shape as a Behavior `setup` function:\n// `({ state, config }) => Reactor`. Each `selectXTrack` export below calls\n// it from inside its own `defineBehavior` setup, supplying its per-type\n// `selectedKey`, track type, default rule chain, and forwarded config. The lifecycle\n// — pick on entering 'presentation-resolved' if not already selected; clear\n// on entering 'presentation-unresolved' — is shared.\n// ============================================================================\n\ntype SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId';\n\ntype SelectStateMap<K extends SelectedTrackKey> = {\n  presentation: ReadonlySignal<TrackSelectionState['presentation']>;\n} & { [P in K]: Signal<TrackSelectionState[P]> };\n\n/** A selection rule over this behavior's candidate tracks. */\nexport type SelectTrackRule<Config> = SelectionRule<SelectableTrack, unknown, unknown, Config | undefined>;\n\n/** What a rule here needs off a candidate: the id it may become the pick by. */\ntype SelectableTrack = { id: string };\n\ninterface TrackSelectionSetupConfig<K extends SelectedTrackKey, RuleConfig> {\n  selectedKey: K;\n  trackType: TrackType;\n  constraints: readonly SelectTrackRule<RuleConfig>[];\n  rules: readonly SelectTrackRule<RuleConfig>[];\n  ruleConfig?: RuleConfig;\n}\n\nfunction setupTrackSelection<K extends SelectedTrackKey, RuleConfig>({\n  state,\n  config: { selectedKey, trackType, constraints, rules, ruleConfig },\n}: {\n  state: SelectStateMap<K>;\n  config: TrackSelectionSetupConfig<K, RuleConfig>;\n}) {\n  const derivedStateSignal = computed(() =>\n    isResolvedPresentation(state.presentation.get())\n      ? ('presentation-resolved' as const)\n      : ('presentation-unresolved' as const)\n  );\n\n  const deps = { state, config: ruleConfig };\n\n  // The playable candidate set — the type's tracks after the hard-constraints\n  // pre-pass. A `computed` so it re-evaluates when its inputs change, which is what\n  // lets a *pinned* selection still notice it has gone unplayable: `resolve-track`\n  // relabels the whole type's container from the first resolved media playlist,\n  // long after `entry` made its pick under the fMP4 default.\n  //\n  // The `equals` gates notification on the set of track ids rather than array\n  // identity, matching `setupTrackSwitching`'s. Segment appends and live reloads\n  // both swap in a new presentation object carrying the same variants; without\n  // this the effect below would re-run on every one of them.\n  const candidateSet = computed(\n    () => {\n      const presentation = state.presentation.get();\n      if (!isResolvedPresentation(presentation)) return [];\n      return applyConstraints(constraints, getTracksByType(presentation, trackType), deps);\n    },\n    { equals: sameCandidateSet }\n  );\n\n  return createMachineReactor({\n    initial: 'presentation-unresolved',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'presentation-unresolved': {},\n      'presentation-resolved': {\n        // Entry: pick a default on entering presentation-resolved if none\n        // is set. External writes (user picks, ABR) that already populated\n        // the slot are left alone.\n        //\n        // The returned cleanup runs on state exit — which fires on src\n        // unload (presentation-resolved → presentation-unresolved) AND on\n        // behavior destroy (presentation-resolved → destroying →\n        // destroyed). Putting the clear here rather than as\n        // presentation-unresolved.entry is more cohesive (operation +\n        // cleanup co-located) and correctly covers destroy (destroy\n        // doesn't pass through presentation-unresolved).\n        entry: () => {\n          if (!state[selectedKey].get()) {\n            // `state.presentation.get()` is non-null inside this entry —\n            // the reactor's `'presentation-resolved'` gate is exactly\n            // `isResolvedPresentation(state.presentation.get())`, which\n            // requires a truthy Presentation.\n            //\n            // Constraints prune the unplayable, then the chain narrows and ranks;\n            // the pick is the head. An empty `rules` chain therefore selects the\n            // first candidate, which falls out of the model rather than needing a\n            // first-track code path of its own.\n            const survivors = applyRules(rules, peek(candidateSet), deps);\n            const id = survivors[0]?.id;\n            if (id) state[selectedKey].set(id);\n          }\n          return () => state[selectedKey].set(undefined);\n        },\n        effects: [\n          // Selection is `entry`'s alone — this only ever *de*selects. Keeping the\n          // pick out of a reaction is what makes this the pinned variant rather\n          // than a worse-spelled `switchVideoTrack`: nothing here re-ranks or moves\n          // the pin. It has to be a reaction all the same, because what it watches\n          // for is learned late — container and encryption come from a rendition's\n          // media playlist, which resolves after the pick was made.\n          //\n          // Deliberately does *not* report why. Whatever made the pick unplayable\n          // reported its own cause as the playlist resolved (1004 container, 4008\n          // encryption, via `reportUnsupportedTrackConditions`), which is both more\n          // specific than a verdict and already logged. The one condition no cause\n          // covers is nothing being playable at all — no rendition resolved, so\n          // none reported — which is why that alone emits here. See\n          // `internal/design/spf/features/errors.md`.\n          () => {\n            // Untracked: writing the slot below must not re-enter this reaction.\n            const selectedId = peek(state[selectedKey]);\n            if (!selectedId) return;\n            if (candidateSet.get().some((track) => track.id === selectedId)) return;\n\n            // Only a pick the source actually offers is this behavior's to drop. An\n            // id absent from the manifest was never selectable, and external writes\n            // are left alone — see this module's header.\n            const presentation = peek(state.presentation);\n            if (\n              isResolvedPresentation(presentation) &&\n              getTracksByType(presentation, trackType).some((track) => track.id === selectedId)\n            ) {\n              state[selectedKey].set(undefined);\n            }\n          },\n        ],\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Default rules\n//\n// Each variant resolves its chain as `config?.rules ?? <default>`. The whole\n// behavior config is forwarded as the rules' `config`, so a policy rule reads\n// its own options (`preferredAudioLanguage`) directly off it.\n//\n// Video's default is the *empty* chain: with no rule narrowing or reordering the\n// candidates, the head is the first track — a consequence of the model rather than\n// a first-track code path of its own.\n// ============================================================================\n\n/** Default video chain: none. The first candidate is the pick. */\nconst DEFAULT_VIDEO_RULES: readonly SelectTrackRule<SelectVideoTrackConfig>[] = [];\n\n/**\n * Default audio chain: the three-tier policy (`preferredAudioLanguage` →\n * `DEFAULT=YES` → first) as a single narrowing rule. Returning `[]` when nothing\n * is picked lets `applyRules` fall through to the unnarrowed candidates, so the\n * head stays the first track — the same last tier the policy itself ends on.\n */\nconst preferAudioPolicy: SelectTrackRule<SelectAudioTrackConfig> = (tracks, { config }) => {\n  const id = pickAudioTrackFromTracks(tracks as readonly { id: string }[], config);\n  const pick = tracks.find((track) => track.id === id);\n  return pick ? [pick] : [];\n};\n\nconst DEFAULT_AUDIO_RULES: readonly SelectTrackRule<SelectAudioTrackConfig>[] = [preferAudioPolicy];\n\n/**\n * Order the candidates by resolution, largest first, with bandwidth breaking ties\n * between renditions of identical dimensions. The background-video default — that\n * variant pins one rendition for the session, and absent a cap the largest is the\n * head.\n *\n * A ranker, so it reorders rather than narrowing: the chain's pick is the head of\n * what it returns, which means ranking never has to collapse to one track. Belongs\n * last in a chain — a sort only reorders what survived the filters ahead of it, and\n * leaving it last is what lets `applyRules` early-bail before it runs.\n *\n * Exported because it is a *rule*, not a variant's private policy: the same one\n * composes into `switchVideoTrack`'s chain when a ranker is wanted there.\n */\nexport const preferHighestResolution: SelectTrackRule<unknown> = (tracks) => [...tracks].sort(byDescendingResolution);\n\n/** What {@link screenResolutionCap} reads off the composition state. */\ntype ScreenResolutionRuleState = {\n  screenResolution?: ReadonlySignal<Resolution | undefined>;\n};\n\n/**\n * Narrow to the renditions that fit the screen, by pixel area — the screen-size\n * cap from `internal/design/spf/features/rendition-selection-caps.md`, as a scope\n * (soft filter) rather than a constraint: an over-cap rendition is wasteful, not\n * unplayable, so nothing here may make a source unplayable.\n *\n * Narrows only — it neither orders the survivors nor resolves the case where none\n * survive, because `applyRules` owns both. So it needs a ranker behind it to pick\n * within the cap: `[screenResolutionCap, preferHighestResolution]` yields the\n * largest rendition that fits. Composed *last*, the pick would instead be whichever\n * fitting rendition the manifest happened to list first.\n *\n * Reading `state.screenResolution` through its signal is what subscribes a\n * re-evaluating chain (`switchVideoTrack`) to screen changes; `selectVideoTrack`\n * pins the first answer instead, by design.\n *\n * Compares areas rather than matching a `\"1080p\"`-style tier because a tier only\n * describes a rendition once you assume its aspect ratio — the assumption that\n * mis-measures an anamorphic ladder. See `media/dom/screen.ts`.\n *\n * Three ways the cap ends up not applying, all of them fall-through:\n *\n * - **No `screenResolution` signal at all**, because the composition omits\n *   `trackScreenResolution`. So composing the cap without its signal source is\n *   inert rather than broken.\n * - **A `screenResolution` of `undefined`**, meaning no screen to read. \"Unknown\"\n *   has to mean \"don't cap\": treating it as an area of zero would pin every source\n *   to its smallest rendition on exactly the environments we know least about.\n * - **No rendition fits**, on a screen smaller than the whole ladder. `applyRules`\n *   skips the empty result and the chain proceeds unnarrowed, so the ranker behind\n *   the cap decides — for `preferHighestResolution`, the largest rendition. A floor\n *   is the fix if that ever matters (`rendition-selection-caps.md` carries one), not\n *   a special case here.\n */\nexport const screenResolutionCap: SelectTrackRule<unknown> = (tracks, { state }) => {\n  const screenResolution = (state as ScreenResolutionRuleState | undefined)?.screenResolution?.get();\n  if (!screenResolution) return [];\n\n  return tracksUnderPixelArea(tracks, screenResolution.width * screenResolution.height);\n};\n\n// ============================================================================\n// Specialized exports — one per track type\n// ============================================================================\n\n/**\n * Config for `selectVideoTrack`. Pass `rules` to replace the selection chain, or\n * `constraints` to replace the capability pre-pass; otherwise the chain is empty\n * and the first playable candidate is the pick.\n */\nexport interface SelectVideoTrackConfig extends CapabilityConstraintConfig {\n  constraints?: readonly SelectTrackRule<SelectVideoTrackConfig>[];\n  rules?: readonly SelectTrackRule<SelectVideoTrackConfig>[];\n}\n\n/**\n * Default video constraints: the capability pre-pass alone. No\n * `excludeFailedCdns` — this variant's compositions run no failover monitor, so\n * `failedCdns` has no writer and the constraint would always pass through.\n */\nconst DEFAULT_VIDEO_CONSTRAINTS: readonly SelectTrackRule<SelectVideoTrackConfig>[] = [excludeUnplayableTracks];\n\n/**\n * Select a video track when a presentation loads. Clears the selection on\n * src unload.\n *\n * This is the simple, non-ABR counterpart to `switchVideoTrack` — compose\n * one or the other, not both (both write `selectedVideoTrackId`). Composing\n * `selectVideoTrack` alone tree-shakes out the ABR code path\n * (bandwidth-estimator, quality-selection); use it for sources without\n * meaningful quality variants, test setups, or players that intentionally\n * pin a quality.\n *\n * @example\n * const reactor = selectVideoTrack.setup({ state });\n */\nexport const selectVideoTrack = defineBehavior({\n  stateKeys: ['presentation', 'selectedVideoTrackId'],\n  contextKeys: [],\n  setup: ({ state, config }: { state: SelectStateMap<'selectedVideoTrackId'>; config?: SelectVideoTrackConfig }) =>\n    setupTrackSelection({\n      state,\n      config: {\n        selectedKey: VIDEO_TYPE_CONFIG.selectedKey,\n        trackType: 'video',\n        constraints: config?.constraints ?? DEFAULT_VIDEO_CONSTRAINTS,\n        rules: config?.rules ?? DEFAULT_VIDEO_RULES,\n        ruleConfig: config,\n      },\n    }),\n});\n\n/**\n * Config for `selectAudioTrack`. Pass `rules` to replace the selection chain, or\n * `constraints` to prune candidates before it runs; otherwise the default\n * three-tier policy applies (`preferredAudioLanguage` → `DEFAULT=YES` → first).\n */\nexport interface SelectAudioTrackConfig extends AudioSelectionConfig {\n  constraints?: readonly SelectTrackRule<SelectAudioTrackConfig>[];\n  rules?: readonly SelectTrackRule<SelectAudioTrackConfig>[];\n}\n\n/**\n * Select an audio track when a presentation loads. Clears the selection\n * on src unload.\n *\n * This is the simple, lifecycle-only counterpart to `switchAudioTrack`\n * (in `./track-switching.ts`) — compose one or the other, not both\n * (both write `selectedAudioTrackId`). `switchAudioTrack` adds\n * filter-reactivity (`userAudioTrackSelection`) and mid-stream-flush\n * orchestration; `selectAudioTrack` covers the default-on-load case\n * without those. Use this variant for test setups, audio-only flows\n * that don't expose language switching, or composition variants that\n * intentionally pin a track.\n *\n * @example\n * const reactor = selectAudioTrack.setup({ state });\n *\n * @example\n * // Language preference, honored by the default audio policy rule\n * const reactor = selectAudioTrack.setup({\n *   state,\n *   config: { preferredAudioLanguage: 'en' },\n * });\n */\nexport const selectAudioTrack = defineBehavior({\n  stateKeys: ['presentation', 'selectedAudioTrackId'],\n  contextKeys: [],\n  setup: ({ state, config }: { state: SelectStateMap<'selectedAudioTrackId'>; config?: SelectAudioTrackConfig }) =>\n    setupTrackSelection({\n      state,\n      config: {\n        selectedKey: AUDIO_TYPE_CONFIG.selectedKey,\n        trackType: 'audio',\n        constraints: config?.constraints ?? [],\n        rules: config?.rules ?? DEFAULT_AUDIO_RULES,\n        ruleConfig: config,\n      },\n    }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2GA,SAAS,oBAA4D,EACnE,OACA,QAAQ,EAAE,aAAa,WAAW,aAAa,OAAO,gBAIrD;CACD,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,IAAI,CAAC,IAC1C,0BACA,yBACP;CAEA,MAAM,OAAO;EAAE;EAAO,QAAQ;CAAW;CAYzC,MAAM,eAAe,eACb;EACJ,MAAM,eAAe,MAAM,aAAa,IAAI;EAC5C,IAAI,CAAC,uBAAuB,YAAY,GAAG,OAAO,CAAC;EACnD,OAAO,iBAAiB,aAAa,gBAAgB,cAAc,SAAS,GAAG,IAAI;CACrF,GACA,EAAE,QAAQ,iBAAiB,CAC7B;CAEA,OAAO,qBAAqB;EAC1B,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,2BAA2B,CAAC;GAC5B,yBAAyB;IAYvB,aAAa;KACX,IAAI,CAAC,MAAM,YAAY,CAAC,IAAI,GAAG;MAW7B,MAAM,KADY,WAAW,OAAO,KAAK,YAAY,GAAG,IACrC,CAAC,CAAC,EAAE,EAAE;MACzB,IAAI,IAAI,MAAM,YAAY,CAAC,IAAI,EAAE;KACnC;KACA,aAAa,MAAM,YAAY,CAAC,IAAI,KAAA,CAAS;IAC/C;IACA,SAAS,OAeD;KAEJ,MAAM,aAAa,KAAK,MAAM,YAAY;KAC1C,IAAI,CAAC,YAAY;KACjB,IAAI,aAAa,IAAI,CAAC,CAAC,MAAM,UAAU,MAAM,OAAO,UAAU,GAAG;KAKjE,MAAM,eAAe,KAAK,MAAM,YAAY;KAC5C,IACE,uBAAuB,YAAY,KACnC,gBAAgB,cAAc,SAAS,CAAC,CAAC,MAAM,UAAU,MAAM,OAAO,UAAU,GAEhF,MAAM,YAAY,CAAC,IAAI,KAAA,CAAS;IAEpC,CACF;GACF;EACF;CACF,CAAC;AACH;;AAeA,MAAM,sBAA0E,CAAC;;;;;;;AAQjF,MAAM,qBAA8D,QAAQ,EAAE,aAAa;CACzF,MAAM,KAAK,yBAAyB,QAAqC,MAAM;CAC/E,MAAM,OAAO,OAAO,MAAM,UAAU,MAAM,OAAO,EAAE;CACnD,OAAO,OAAO,CAAC,IAAI,IAAI,CAAC;AAC1B;AAEA,MAAM,sBAA0E,CAAC,iBAAiB;;;;;;;;;;;;;;;AAgBlG,MAAa,2BAAqD,WAAW,CAAC,GAAG,MAAM,CAAC,CAAC,KAAK,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCpH,MAAa,uBAAiD,QAAQ,EAAE,YAAY;CAClF,MAAM,mBAAoB,OAAiD,kBAAkB,IAAI;CACjG,IAAI,CAAC,kBAAkB,OAAO,CAAC;CAE/B,OAAO,qBAAqB,QAAQ,iBAAiB,QAAQ,iBAAiB,MAAM;AACtF;;;;;;AAqBA,MAAM,4BAAgF,CAAC,uBAAuB;;;;;;;;;;;;;;;AAgB9G,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,CAAC;CACd,QAAQ,EAAE,OAAO,aACf,oBAAoB;EAClB;EACA,QAAQ;GACN,aAAa,kBAAkB;GAC/B,WAAW;GACX,aAAa,QAAQ,eAAe;GACpC,OAAO,QAAQ,SAAS;GACxB,YAAY;EACd;CACF,CAAC;AACL,CAAC;AAmC+B,eAAe;CAC7C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,CAAC;CACd,QAAQ,EAAE,OAAO,aACf,oBAAoB;EAClB;EACA,QAAQ;GACN,aAAa,kBAAkB;GAC/B,WAAW;GACX,aAAa,QAAQ,eAAe,CAAC;GACrC,OAAO,QAAQ,SAAS;GACxB,YAAY;EACd;CACF,CAAC;AACL,CAAC"}

package/dist/dev/playback/behaviors/setup-failover-monitor.d.ts

@@ -0,0 +1,14 @@
+import "../../core/signals/primitives.js";
+import "../../index.js";
+//#region src/playback/behaviors/setup-failover-monitor.d.ts
+/**
+ * Failover policy: how long a CDN stays excluded after a failed fetch trips it.
+ * Supplied via engine config.
+ */
+interface FailoverMonitorConfig {
+  /** How long a tripped CDN stays excluded, in milliseconds. */
+  cooldownMs: number;
+}
+//#endregion
+export { FailoverMonitorConfig };
+//# sourceMappingURL=setup-failover-monitor.d.ts.map

package/dist/dev/playback/behaviors/setup-failover-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-failover-monitor.d.ts","names":[],"sources":["../../../../src/playback/behaviors/setup-failover-monitor.ts"],"mappings":";;;;;;;UA0BiB;;EAEf"}

package/dist/dev/playback/behaviors/setup-failover-monitor.js

@@ -0,0 +1,66 @@
+import { computed, update } from "../../core/signals/primitives.js";
+import { defineBehavior } from "../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../core/reactors/create-machine-reactor.js";
+import { isResolvedPresentation } from "../../media/types/index.js";
+//#region src/playback/behaviors/setup-failover-monitor.ts
+/**
+* **CDN failover cooldown.** The expiry half of multi-CDN failover. Fetch sites
+* own the *trip*: on a failed fetch they add the failing CDN (origin) to the
+* `failedCdns` state signal directly. This behavior owns the *expiry*: while a
+* presentation is resolved, it watches `failedCdns` and, for each CDN that
+* appears, schedules a timer to remove it once its cooldown lapses.
+* `track-switching`'s `excludeFailedCdns` constraint prunes a failed CDN's
+* tracks and the active-CDN scope falls to the next one — and back, once the
+* cooldown removes it here.
+*
+* Lifecycle is per-source: timers + `failedCdns` are cleared on exit (a new
+* source starts with a clean slate). Policy (cooldown) is engine config. This is
+* the minimal `network-resilience` slice — a single failure trips a CDN, since
+* transient blips are the retry layer's job (it sits below the fetch sites, so
+* anything that reaches `failedCdns` is already terminal).
+*/
+const DEFAULT_FAILOVER_MONITOR_CONFIG = { cooldownMs: 3e5 };
+/**
+* Expire failed CDNs from `failedCdns` once their cooldown lapses, for the
+* resolved source.
+*
+* @example
+* const reactor = setupFailoverMonitor.setup({ state });
+*/
+const setupFailoverMonitor = defineBehavior({
+	stateKeys: ["presentation", "failedCdns"],
+	contextKeys: [],
+	setup: ({ state, config = {} }) => {
+		const cooldownMs = config.failover?.cooldownMs ?? DEFAULT_FAILOVER_MONITOR_CONFIG.cooldownMs;
+		const timers = /* @__PURE__ */ new Map();
+		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: () => () => {
+						timers.forEach((timer) => clearTimeout(timer));
+						timers.clear();
+						state.failedCdns.set(void 0);
+					},
+					effects: [() => {
+						(state.failedCdns.get() ?? []).forEach((cdn) => {
+							if (timers.has(cdn)) return;
+							const timer = setTimeout(() => {
+								timers.delete(cdn);
+								update(state.failedCdns, (current) => current?.filter((c) => c !== cdn));
+							}, cooldownMs);
+							timers.set(cdn, timer);
+						});
+					}]
+				}
+			}
+		});
+	}
+});
+//#endregion
+export { DEFAULT_FAILOVER_MONITOR_CONFIG, setupFailoverMonitor };
+
+//# sourceMappingURL=setup-failover-monitor.js.map

package/dist/dev/playback/behaviors/setup-failover-monitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-failover-monitor.js","names":[],"sources":["../../../../src/playback/behaviors/setup-failover-monitor.ts"],"sourcesContent":["/**\n * **CDN failover cooldown.** The expiry half of multi-CDN failover. Fetch sites\n * own the *trip*: on a failed fetch they add the failing CDN (origin) to the\n * `failedCdns` state signal directly. This behavior owns the *expiry*: while a\n * presentation is resolved, it watches `failedCdns` and, for each CDN that\n * appears, schedules a timer to remove it once its cooldown lapses.\n * `track-switching`'s `excludeFailedCdns` constraint prunes a failed CDN's\n * tracks and the active-CDN scope falls to the next one — and back, once the\n * cooldown removes it here.\n *\n * Lifecycle is per-source: timers + `failedCdns` are cleared on exit (a new\n * source starts with a clean slate). Policy (cooldown) is engine config. This is\n * the minimal `network-resilience` slice — a single failure trips a CDN, since\n * transient blips are the retry layer's job (it sits below the fetch sites, so\n * anything that reaches `failedCdns` is already terminal).\n */\n\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal, update } from '../../core/signals/primitives';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';\n\n/**\n * Failover policy: how long a CDN stays excluded after a failed fetch trips it.\n * Supplied via engine config.\n */\nexport interface FailoverMonitorConfig {\n  /** How long a tripped CDN stays excluded, in milliseconds. */\n  cooldownMs: number;\n}\n\nexport const DEFAULT_FAILOVER_MONITOR_CONFIG: FailoverMonitorConfig = {\n  // 5 minutes — a CDN outage is an infrastructure problem that outlasts a\n  // transient blip, so re-probing it sooner mostly re-trips. Matches the\n  // prevailing prior-art default (ExoPlayer's location exclusion, hls.js's\n  // content-steering penalty box).\n  cooldownMs: 300_000,\n};\n\nexport interface SetupFailoverMonitorState {\n  presentation?: MaybeResolvedPresentation;\n  failedCdns?: string[];\n}\n\nexport interface SetupFailoverMonitorConfig {\n  /** Failover policy (cooldown); defaults to `DEFAULT_FAILOVER_MONITOR_CONFIG`. */\n  failover?: Partial<FailoverMonitorConfig>;\n}\n\n/**\n * Expire failed CDNs from `failedCdns` once their cooldown lapses, for the\n * resolved source.\n *\n * @example\n * const reactor = setupFailoverMonitor.setup({ state });\n */\nexport const setupFailoverMonitor = defineBehavior({\n  stateKeys: ['presentation', 'failedCdns'],\n  contextKeys: [],\n  setup: ({\n    state,\n    config = {},\n  }: {\n    state: {\n      presentation: ReadonlySignal<SetupFailoverMonitorState['presentation']>;\n      failedCdns: Signal<SetupFailoverMonitorState['failedCdns']>;\n    };\n    config?: SetupFailoverMonitorConfig;\n  }) => {\n    const cooldownMs = config.failover?.cooldownMs ?? DEFAULT_FAILOVER_MONITOR_CONFIG.cooldownMs;\n    // CDN id → its pending cooldown-removal timer. Shared by the `effects`\n    // scheduler (adds a timer per newly-failed CDN) and the exit cleanup\n    // (clears them). Per-source: emptied on exit, so it re-enters clean.\n    const timers = new Map<string, ReturnType<typeof setTimeout>>();\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: on exit (src unload + destroy) clear the\n          // pending timers and reset `failedCdns` for the next source.\n          entry: () => () => {\n            timers.forEach((timer) => clearTimeout(timer));\n            timers.clear();\n            state.failedCdns.set(undefined);\n          },\n          effects: [\n            () => {\n              const failed = state.failedCdns.get() ?? [];\n              failed.forEach((cdn) => {\n                // Idempotent: a CDN already counting down keeps its original\n                // deadline (re-failing it mid-cooldown doesn't extend it).\n                if (timers.has(cdn)) return;\n                const timer = setTimeout(() => {\n                  timers.delete(cdn);\n                  update(state.failedCdns, (current) => current?.filter((c) => c !== cdn));\n                }, cooldownMs);\n                timers.set(cdn, timer);\n              });\n            },\n          ],\n        },\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,kCAAyD,EAKpE,YAAY,IACd;;;;;;;;AAmBA,MAAa,uBAAuB,eAAe;CACjD,WAAW,CAAC,gBAAgB,YAAY;CACxC,aAAa,CAAC;CACd,QAAQ,EACN,OACA,SAAS,CAAC,QAON;EACJ,MAAM,aAAa,OAAO,UAAU,cAAc,gCAAgC;EAIlF,MAAM,yBAAS,IAAI,IAA2C;EAC9D,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;MACjB,OAAO,SAAS,UAAU,aAAa,KAAK,CAAC;MAC7C,OAAO,MAAM;MACb,MAAM,WAAW,IAAI,KAAA,CAAS;KAChC;KACA,SAAS,OACD;MAEJ,CADe,MAAM,WAAW,IAAI,KAAK,CAAC,EAAA,CACnC,SAAS,QAAQ;OAGtB,IAAI,OAAO,IAAI,GAAG,GAAG;OACrB,MAAM,QAAQ,iBAAiB;QAC7B,OAAO,OAAO,GAAG;QACjB,OAAO,MAAM,aAAa,YAAY,SAAS,QAAQ,MAAM,MAAM,GAAG,CAAC;OACzE,GAAG,UAAU;OACb,OAAO,IAAI,KAAK,KAAK;MACvB,CAAC;KACH,CACF;IACF;GACF;EACF,CAAC;CACH;AACF,CAAC"}