@videojs/spf 10.0.0-beta.24 → 10.0.0-beta.25

package/dist/default/playback/behaviors/dom/sync-text-tracks.js.map

@@ -1 +1 @@
-{"version":3,"file":"sync-text-tracks.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/sync-text-tracks.ts"],"sourcesContent":["/**\n * **Own the text-track slots on the host media element, mirroring the SPF\n * model.** When a presentation is resolved and a media element is\n * available, allocate one slot in `mediaElement.textTracks` per model text\n * track — via creating `<track>` children, since that's the only spec\n * mechanism for adding *and* removing entries to `textTracks` (no\n * `removeTextTrack` API exists). Once slots are provisioned, mirror\n * `selectedTextTrackId` into their `mode`s, and propagate user-initiated\n * DOM `change` events back to `selectedTextTrackId` so non-SPF consumers\n * (host-page captions buttons, browser native UI, video.js store) remain\n * the canonical write path for selection.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`):\n * the entry allocates the slots, applies the initial selection, attaches\n * the `change` listener, and opens a brief Chromium settling-window guard —\n * all transition-driven, fire-once on state entry, with paired cleanup on\n * state exit. A single `effects:` mirrors subsequent\n * `selectedTextTrackId` changes into `mode`s; that's the only\n * continuous-reactivity concern.\n *\n * State-exit cleanup also sends a `'clear'` message to the\n * `TextTracksActor` so its cue+segment cache (keyed by trackId) is\n * dropped alongside the DOM `<track>` slots. The actor itself is owned\n * by `setupTextTrackActors` and bound to mediaElement, not presentation,\n * so it survives source resets; clearing its context here keeps the\n * cache consistent with the DOM. Without this, a subsequent\n * presentation reusing a trackId would have `getSegmentsToLoad` treat\n * its segments as already-buffered and skip loading them.\n *\n * Multi-writer with `selectTextTrack` is intentional and orthogonal:\n * `selectTextTrack` owns the *default-on-load / clear-on-unload* contract\n * for `selectedTextTrackId`; this behavior writes only from DOM `change`\n * events. They reflect distinct decision-making domains (config-driven\n * intent vs DOM-driven user action), so this behavior never clears the\n * slot on source unload — that's `selectTextTrack`'s contract. (It *does*\n * write `undefined` when a user disables all tracks via native UI, since\n * that's a real user action that should round-trip into SPF state.)\n */\n\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { syncTextTrackModes } from '../../../media/dom/text/text-track-slots';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTextTrack, TextTrack } from '../../../media/types';\nimport { getTracksByType } from '../../../media/utils/tracks';\nimport type { TextTracksActor } from '../../actors/text-tracks';\n\ntype SyncTextTracksFsmState = 'preconditions-unmet' | 'sync-active';\n\nexport interface SyncTextTracksConfig {\n  /**\n   * Create and append SPF-owned `<track>` slots on `mediaElement`, one per\n   * model text track. Implementation tags each element so the read/remove\n   * helpers can scope to SPF-owned slots. **Required** — the behavior is\n   * DOM-binding-neutral and the composing engine supplies the integration.\n   */\n  addSubtitlesTracksToMedia: (\n    mediaElement: HTMLMediaElement,\n    modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n  ) => void;\n  /**\n   * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`\n   * mode, or `undefined` if none. Used by the DOM `change` bridge to mirror\n   * native-UI selection back into `selectedTextTrackId`.\n   */\n  getShowingSubtitlesTrackFromMedia: (mediaElement: HTMLMediaElement) => globalThis.TextTrack | undefined;\n  /**\n   * Remove every SPF-owned `<track>` child from `mediaElement`. Called on\n   * state exit (source unload, behavior destroy) to evict slots.\n   */\n  removeAllSubtitlesTracksFromMedia: (mediaElement: HTMLMediaElement) => void;\n}\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined\n): SyncTextTracksFsmState {\n  if (!mediaElement || !presentation) return 'preconditions-unmet';\n  return getTracksByType(presentation, 'text').length > 0 ? 'sync-active' : 'preconditions-unmet';\n}\n\nfunction syncTextTracksSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n    selectedTextTrackId: Signal<string | undefined>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<HTMLMediaElement | undefined>;\n    textTracksActor: ReadonlySignal<TextTracksActor<VTTCue> | undefined>;\n  };\n  config: SyncTextTracksConfig;\n}): Reactor<SyncTextTracksFsmState | 'destroying' | 'destroyed'> {\n  const { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } = config;\n\n  const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));\n\n  return createMachineReactor<SyncTextTracksFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'sync-active': {\n        // Allocate slots, apply the initial selection, attach the change\n        // listener, and open the settling window — all transition-driven\n        // (fire once per state entry). Entry is auto-untracked, so `.get()`\n        // here doesn't subscribe; the returned cleanup detaches and evicts\n        // on state exit (src reset through 'preconditions-unmet') and on\n        // destroy.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          // `getTracksByType('text', ...)` returns text tracks only — the\n          // selection-set filter inside the helper ensures that — but its\n          // declared return is the wide track union. Mirror the cast\n          // pattern used by `quality-switching` for the video branch.\n          const modelTextTracks = getTracksByType(state.presentation.get()!, 'text') as readonly (\n            | PartiallyResolvedTextTrack\n            | TextTrack\n          )[];\n\n          addSubtitlesTracksToMedia(mediaElement, modelTextTracks);\n          // Apply our selection synchronously so the change-event tasks\n          // these mode writes queue land in the macrotask queue *before*\n          // the settling-close `setTimeout(0)` queued below. This keeps\n          // the settling window open long enough to swallow Chromium's\n          // own auto-selection task (also scheduled in the next tick after\n          // `<track>` insertion); if the order flipped, our handler would\n          // treat Chromium's auto-pick as a user action. The `effects:`\n          // block below handles subsequent `selectedTextTrackId` changes.\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n\n          // Chromium re-applies its own selection across the next task tick\n          // after `<track>` insertion (default-track auto-pick, language\n          // preference). During this window, the `change` event may fire\n          // with browser-chosen modes that don't reflect a real user action;\n          // re-apply our modes silently rather than writing them back.\n          let inSettlingWindow = true;\n          const settlingTimeout = setTimeout(() => {\n            inSettlingWindow = false;\n          }, 0);\n\n          const onChange = (): void => {\n            if (inSettlingWindow) {\n              syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n              return;\n            }\n            const showingTrack = getShowingSubtitlesTrackFromMedia(mediaElement);\n            // `showingTrack.id` matches the SPF id we set when the slot was\n            // allocated. Empty-string ids fall through to `undefined`.\n            const nextId = showingTrack?.id || undefined;\n            if (nextId === state.selectedTextTrackId.get()) return;\n            state.selectedTextTrackId.set(nextId);\n          };\n\n          const unlisten = listen(mediaElement.textTracks, 'change', onChange);\n\n          return () => {\n            unlisten();\n            clearTimeout(settlingTimeout);\n            removeAllSubtitlesTracksFromMedia(mediaElement);\n            // Clear the TextTracksActor's cue+segment cache, which is\n            // keyed by trackId. If we don't, a subsequent presentation\n            // reusing a trackId would have `getSegmentsToLoad` treat its\n            // segments as already-buffered. The DOM cleanup above\n            // already evicted the live cues; this drops the cache that\n            // tracked them. The actor itself is owned by\n            // `setupTextTrackActors` (mediaElement-bound lifecycle), so\n            // we send rather than destroy.\n            peek(context.textTracksActor)?.send({ type: 'clear' });\n          };\n        },\n\n        // Mirror selection changes into mode. The state machine handles\n        // mediaElement/presentation changes via 'preconditions-unmet'\n        // round-trips, so we peek mediaElement here.\n        effects: () => {\n          const mediaElement = peek(context.mediaElement)!;\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n        },\n      },\n    },\n  });\n}\n\nexport const syncTextTracks = defineBehavior({\n  stateKeys: ['presentation', 'selectedTextTrackId'],\n  contextKeys: ['mediaElement', 'textTracksActor'],\n  setup: syncTextTracksSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,SAAS,YACP,cACA,cACwB;AACxB,KAAI,CAAC,gBAAgB,CAAC,aAAc,QAAO;AAC3C,QAAO,gBAAgB,cAAc,OAAO,CAAC,SAAS,IAAI,gBAAgB;;AAG5E,SAAS,oBAAoB,EAC3B,OACA,SACA,UAW+D;CAC/D,MAAM,EAAE,2BAA2B,mCAAmC,sCAAsC;CAE5G,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,KAAK,EAAE,QAAQ,aAAa,KAAK,CAAC,CAAC;AAE5G,QAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,eAAe;IAOb,aAAa;KACX,MAAM,eAAe,QAAQ,aAAa,KAAK;AAU/C,+BAA0B,cALF,gBAAgB,MAAM,aAAa,KAAK,EAAG,OAAO,CAKlB;AASxD,wBAAmB,aAAa,YAAY,MAAM,oBAAoB,KAAK,CAAC;KAO5E,IAAI,mBAAmB;KACvB,MAAM,kBAAkB,iBAAiB;AACvC,yBAAmB;QAClB,EAAE;KAEL,MAAM,iBAAuB;AAC3B,UAAI,kBAAkB;AACpB,0BAAmB,aAAa,YAAY,MAAM,oBAAoB,KAAK,CAAC;AAC5E;;MAKF,MAAM,SAHe,kCAAkC,aAAa,EAGvC,MAAM,KAAA;AACnC,UAAI,WAAW,MAAM,oBAAoB,KAAK,CAAE;AAChD,YAAM,oBAAoB,IAAI,OAAO;;KAGvC,MAAM,WAAW,OAAO,aAAa,YAAY,UAAU,SAAS;AAEpE,kBAAa;AACX,gBAAU;AACV,mBAAa,gBAAgB;AAC7B,wCAAkC,aAAa;AAS/C,WAAK,QAAQ,gBAAgB,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;;;IAO1D,eAAe;AAEb,wBADqB,KAAK,QAAQ,aAAa,CACf,YAAY,MAAM,oBAAoB,KAAK,CAAC;;IAE/E;GACF;EACF,CAAC;;AAGJ,MAAa,iBAAiB,eAAe;CAC3C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,CAAC,gBAAgB,kBAAkB;CAChD,OAAO;CACR,CAAC"}
+{"version":3,"file":"sync-text-tracks.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/sync-text-tracks.ts"],"sourcesContent":["/**\n * **Own the text-track slots on the host media element, mirroring the SPF\n * model.** When a presentation is resolved and a media element is\n * available, allocate one slot in `mediaElement.textTracks` per model text\n * track — via creating `<track>` children, since that's the only spec\n * mechanism for adding *and* removing entries to `textTracks` (no\n * `removeTextTrack` API exists). Once slots are provisioned, mirror the\n * resolved `selectedTextTrackId` into their `mode`s (one-way: state → DOM),\n * and propagate user-initiated DOM `change` events back to\n * `userTextTrackSelection` — the standing *intent* (a language-based partial,\n * or `'off'`) that `switchTextTrack` resolves into `selectedTextTrackId`. So\n * non-SPF consumers (host-page captions buttons, browser native UI, video.js\n * store) drive selection by expressing intent, not by writing the resolved id.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`):\n * the entry allocates the slots, applies the initial selection, attaches\n * the `change` listener, and opens a brief Chromium settling-window guard —\n * all transition-driven, fire-once on state entry, with paired cleanup on\n * state exit. A single `effects:` mirrors subsequent\n * `selectedTextTrackId` changes into `mode`s; that's the only\n * continuous-reactivity concern.\n *\n * State-exit cleanup also sends a `'clear'` message to the\n * `TextTracksActor` so its cue+segment cache (keyed by trackId) is\n * dropped alongside the DOM `<track>` slots. The actor itself is owned\n * by `setupTextTrackActors` and bound to mediaElement, not presentation,\n * so it survives source resets; clearing its context here keeps the\n * cache consistent with the DOM. Without this, a subsequent\n * presentation reusing a trackId would have `getSegmentsToLoad` treat\n * its segments as already-buffered and skip loading them.\n *\n * Single-writer separation: `selectedTextTrackId` is the resolved *output*\n * owned solely by `switchTextTrack`; this behavior only reads it (to mirror\n * modes). The write path here is `userTextTrackSelection` — the user-intent\n * *input* — so DOM action and the resolver never contend for one slot. The\n * intent isn't cleared on source unload (it's a standing preference, like\n * `userAudioTrackSelection`); `'off'` is written when the user disables all\n * tracks via native UI.\n *\n * Echo guard: `selectedTextTrackId` is exactly the id this behavior last drove\n * into the DOM, so a `change` event still showing it is our own echo (or a\n * resolver-driven correction — e.g. the picked track's CDN failed and the\n * resolver disabled it) and is ignored, never written back as a spurious user\n * action. Only a showing id that *differs* from the resolved id is a real user\n * pick. The settling-window guard additionally swallows Chromium's init-time\n * auto-selection before the resolved selection has settled.\n */\n\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { syncTextTrackModes } from '../../../media/dom/text/text-track-slots';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTextTrack, TextTrack } from '../../../media/types';\nimport { getTracksByType } from '../../../media/utils/tracks';\nimport type { TextTracksActor } from '../../actors/text-tracks';\n\ntype SyncTextTracksFsmState = 'preconditions-unmet' | 'sync-active';\n\nexport interface SyncTextTracksConfig {\n  /**\n   * Create and append SPF-owned `<track>` slots on `mediaElement`, one per\n   * model text track. Implementation tags each element so the read/remove\n   * helpers can scope to SPF-owned slots. **Required** — the behavior is\n   * DOM-binding-neutral and the composing engine supplies the integration.\n   */\n  addSubtitlesTracksToMedia: (\n    mediaElement: HTMLMediaElement,\n    modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n  ) => void;\n  /**\n   * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`\n   * mode, or `undefined` if none. Used by the DOM `change` bridge to mirror\n   * native-UI selection back into `selectedTextTrackId`.\n   */\n  getShowingSubtitlesTrackFromMedia: (mediaElement: HTMLMediaElement) => globalThis.TextTrack | undefined;\n  /**\n   * Remove every SPF-owned `<track>` child from `mediaElement`. Called on\n   * state exit (source unload, behavior destroy) to evict slots.\n   */\n  removeAllSubtitlesTracksFromMedia: (mediaElement: HTMLMediaElement) => void;\n}\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaElement: HTMLMediaElement | undefined\n): SyncTextTracksFsmState {\n  if (!mediaElement || !presentation) return 'preconditions-unmet';\n  return getTracksByType(presentation, 'text').length > 0 ? 'sync-active' : 'preconditions-unmet';\n}\n\n/**\n * Map the DOM-showing track back to standing user intent. No showing track is an\n * explicit `'off'`. Otherwise prefer a language-based partial (so the pick\n * persists across source changes); fall back to `{ id }` for a track without a\n * language (precise within a source, just not portable).\n */\nfunction deriveTextTrackIntent(\n  showingId: string | undefined,\n  modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n): Partial<TextTrack> | 'off' {\n  if (!showingId) return 'off';\n  const language = modelTextTracks.find((track) => track.id === showingId)?.language;\n  return language ? { language } : { id: showingId };\n}\n\nfunction syncTextTracksSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;\n    // Read-only here: the resolved output owned by `switchTextTrack`, mirrored\n    // into DOM modes and used as the echo-guard reference.\n    selectedTextTrackId: ReadonlySignal<string | undefined>;\n    // The write path: standing user intent the DOM bridge feeds.\n    userTextTrackSelection: Signal<Partial<TextTrack> | 'off' | undefined>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<HTMLMediaElement | undefined>;\n    textTracksActor: ReadonlySignal<TextTracksActor<VTTCue> | undefined>;\n  };\n  config: SyncTextTracksConfig;\n}): Reactor<SyncTextTracksFsmState | 'destroying' | 'destroyed'> {\n  const { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } = config;\n\n  const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));\n\n  return createMachineReactor<SyncTextTracksFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'sync-active': {\n        // Allocate slots, apply the initial selection, attach the change\n        // listener, and open the settling window — all transition-driven\n        // (fire once per state entry). Entry is auto-untracked, so `.get()`\n        // here doesn't subscribe; the returned cleanup detaches and evicts\n        // on state exit (src reset through 'preconditions-unmet') and on\n        // destroy.\n        entry: () => {\n          const mediaElement = context.mediaElement.get()!;\n          // `getTracksByType('text', ...)` returns text tracks only — the\n          // selection-set filter inside the helper ensures that — but its\n          // declared return is the wide track union. Mirror the cast\n          // pattern used by `track-switching` for the video branch.\n          const modelTextTracks = getTracksByType(state.presentation.get()!, 'text') as readonly (\n            | PartiallyResolvedTextTrack\n            | TextTrack\n          )[];\n\n          addSubtitlesTracksToMedia(mediaElement, modelTextTracks);\n          // Apply our selection synchronously so the change-event tasks\n          // these mode writes queue land in the macrotask queue *before*\n          // the settling-close `setTimeout(0)` queued below. This keeps\n          // the settling window open long enough to swallow Chromium's\n          // own auto-selection task (also scheduled in the next tick after\n          // `<track>` insertion); if the order flipped, our handler would\n          // treat Chromium's auto-pick as a user action. The `effects:`\n          // block below handles subsequent `selectedTextTrackId` changes.\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n\n          // Chromium re-applies its own selection across the next task tick\n          // after `<track>` insertion (default-track auto-pick, language\n          // preference). During this window, the `change` event may fire\n          // with browser-chosen modes that don't reflect a real user action;\n          // re-apply our modes silently rather than writing them back.\n          let inSettlingWindow = true;\n          const settlingTimeout = setTimeout(() => {\n            inSettlingWindow = false;\n          }, 0);\n\n          const onChange = (): void => {\n            if (inSettlingWindow) {\n              syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n              return;\n            }\n            const showingTrack = getShowingSubtitlesTrackFromMedia(mediaElement);\n            // `showingTrack.id` matches the SPF id we set when the slot was\n            // allocated. Empty-string ids fall through to `undefined`.\n            const showingId = showingTrack?.id || undefined;\n            // Echo guard: selectedTextTrackId is the id we last drove into the\n            // DOM (mirror / resolver correction). A change still showing it is our\n            // own echo — ignore it rather than write spurious intent.\n            if (showingId === state.selectedTextTrackId.get()) return;\n            // Genuine user action → write intent (resolved into selectedTextTrackId\n            // by switchTextTrack), not the resolved id.\n            state.userTextTrackSelection.set(deriveTextTrackIntent(showingId, modelTextTracks));\n          };\n\n          const unlisten = listen(mediaElement.textTracks, 'change', onChange);\n\n          return () => {\n            unlisten();\n            clearTimeout(settlingTimeout);\n            removeAllSubtitlesTracksFromMedia(mediaElement);\n            // Clear the TextTracksActor's cue+segment cache, which is\n            // keyed by trackId. If we don't, a subsequent presentation\n            // reusing a trackId would have `getSegmentsToLoad` treat its\n            // segments as already-buffered. The DOM cleanup above\n            // already evicted the live cues; this drops the cache that\n            // tracked them. The actor itself is owned by\n            // `setupTextTrackActors` (mediaElement-bound lifecycle), so\n            // we send rather than destroy.\n            peek(context.textTracksActor)?.send({ type: 'clear' });\n          };\n        },\n\n        // Mirror selection changes into mode. The state machine handles\n        // mediaElement/presentation changes via 'preconditions-unmet'\n        // round-trips, so we peek mediaElement here.\n        effects: () => {\n          const mediaElement = peek(context.mediaElement)!;\n          syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());\n        },\n      },\n    },\n  });\n}\n\nexport const syncTextTracks = defineBehavior({\n  stateKeys: ['presentation', 'selectedTextTrackId', 'userTextTrackSelection'],\n  contextKeys: ['mediaElement', 'textTracksActor'],\n  setup: syncTextTracksSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,SAAS,YACP,cACA,cACwB;AACxB,KAAI,CAAC,gBAAgB,CAAC,aAAc,QAAO;AAC3C,QAAO,gBAAgB,cAAc,OAAO,CAAC,SAAS,IAAI,gBAAgB;;;;;;;;AAS5E,SAAS,sBACP,WACA,iBAC4B;AAC5B,KAAI,CAAC,UAAW,QAAO;CACvB,MAAM,WAAW,gBAAgB,MAAM,UAAU,MAAM,OAAO,UAAU,EAAE;AAC1E,QAAO,WAAW,EAAE,UAAU,GAAG,EAAE,IAAI,WAAW;;AAGpD,SAAS,oBAAoB,EAC3B,OACA,SACA,UAe+D;CAC/D,MAAM,EAAE,2BAA2B,mCAAmC,sCAAsC;CAE5G,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,KAAK,EAAE,QAAQ,aAAa,KAAK,CAAC,CAAC;AAE5G,QAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,eAAe;IAOb,aAAa;KACX,MAAM,eAAe,QAAQ,aAAa,KAAK;KAK/C,MAAM,kBAAkB,gBAAgB,MAAM,aAAa,KAAK,EAAG,OAAO;AAK1E,+BAA0B,cAAc,gBAAgB;AASxD,wBAAmB,aAAa,YAAY,MAAM,oBAAoB,KAAK,CAAC;KAO5E,IAAI,mBAAmB;KACvB,MAAM,kBAAkB,iBAAiB;AACvC,yBAAmB;QAClB,EAAE;KAEL,MAAM,iBAAuB;AAC3B,UAAI,kBAAkB;AACpB,0BAAmB,aAAa,YAAY,MAAM,oBAAoB,KAAK,CAAC;AAC5E;;MAKF,MAAM,YAHe,kCAAkC,aAAa,EAGpC,MAAM,KAAA;AAItC,UAAI,cAAc,MAAM,oBAAoB,KAAK,CAAE;AAGnD,YAAM,uBAAuB,IAAI,sBAAsB,WAAW,gBAAgB,CAAC;;KAGrF,MAAM,WAAW,OAAO,aAAa,YAAY,UAAU,SAAS;AAEpE,kBAAa;AACX,gBAAU;AACV,mBAAa,gBAAgB;AAC7B,wCAAkC,aAAa;AAS/C,WAAK,QAAQ,gBAAgB,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;;;IAO1D,eAAe;AAEb,wBADqB,KAAK,QAAQ,aAAa,CACf,YAAY,MAAM,oBAAoB,KAAK,CAAC;;IAE/E;GACF;EACF,CAAC;;AAGJ,MAAa,iBAAiB,eAAe;CAC3C,WAAW;EAAC;EAAgB;EAAuB;EAAyB;CAC5E,aAAa,CAAC,gBAAgB,kBAAkB;CAChD,OAAO;CACR,CAAC"}

package/dist/default/playback/behaviors/dom/track-current-time.js

@@ -9,6 +9,10 @@ import { listen } from "@videojs/utils/dom";
 *   at the new position when this event dispatches, so buffer management can
 *   react immediately rather than waiting for `timeupdate`, which does not
 *   fire while paused.
+* - `emptied` — fires when the resource selection algorithm tears down the
+*   current media (e.g. a new `src` is set on the same element). Re-syncs so
+*   downstream state doesn't retain the stale playback position from the
+*   previous source when the engine is reused across src changes.
 *
 * Also syncs immediately when a media element becomes available.
 *
@@ -27,9 +31,11 @@ function trackCurrentTimeSetup({ state, context, config }) {
 		}
 		const sync = () => state.currentTime.set(mediaElement.currentTime);
 		sync();
+		const removeEmptied = listen(mediaElement, "emptied", sync);
 		const removeTimeupdate = listen(mediaElement, "timeupdate", sync);
 		const removeSeeking = listen(mediaElement, "seeking", sync);
 		return () => {
+			removeEmptied();
 			removeTimeupdate();
 			removeSeeking();
 		};

package/dist/default/playback/behaviors/dom/track-current-time.js.map

@@ -1 +1 @@
-{"version":3,"file":"track-current-time.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-current-time.ts"],"sourcesContent":["/**\n * Mirror `mediaElement.currentTime` into reactive state. Listens for:\n * - `timeupdate` — fires during playback (~4 Hz)\n * - `seeking` — fires when a seek begins; per spec, `currentTime` is already\n *   at the new position when this event dispatches, so buffer management can\n *   react immediately rather than waiting for `timeupdate`, which does not\n *   fire while paused.\n *\n * Also syncs immediately when a media element becomes available.\n *\n * When no media element is attached, writes `config.defaultCurrentTime`\n * (default-default `0`, matching the HTMLMediaElement spec) so consumers\n * always see a defined position. Read-only mirror; does not push\n * `state.currentTime` back to the element.\n */\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\n\nexport interface CurrentTimeState {\n  currentTime?: number;\n}\n\nexport interface CurrentTimeContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface TrackCurrentTimeConfig {\n  /**\n   * Value written to `state.currentTime` when no media element is attached.\n   * Defaults to `0` — the HTMLMediaElement spec default.\n   */\n  defaultCurrentTime?: number;\n}\n\nfunction trackCurrentTimeSetup({\n  state,\n  context,\n  config,\n}: {\n  state: { currentTime: Signal<CurrentTimeState['currentTime']> };\n  context: { mediaElement: ReadonlySignal<CurrentTimeContext['mediaElement']> };\n  config?: TrackCurrentTimeConfig;\n}): () => void {\n  const defaultCurrentTime = config?.defaultCurrentTime ?? 0;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) {\n      state.currentTime.set(defaultCurrentTime);\n      return;\n    }\n\n    const sync = () => state.currentTime.set(mediaElement.currentTime);\n    sync();\n    const removeTimeupdate = listen(mediaElement, 'timeupdate', sync);\n    const removeSeeking = listen(mediaElement, 'seeking', sync);\n    return () => {\n      removeTimeupdate();\n      removeSeeking();\n    };\n  });\n}\n\nexport const trackCurrentTime = defineBehavior({\n  stateKeys: ['currentTime'],\n  contextKeys: ['mediaElement'],\n  setup: trackCurrentTimeSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoCA,SAAS,sBAAsB,EAC7B,OACA,SACA,UAKa;CACb,MAAM,qBAAqB,QAAQ,sBAAsB;AAEzD,QAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,KAAK;AAC/C,MAAI,CAAC,cAAc;AACjB,SAAM,YAAY,IAAI,mBAAmB;AACzC;;EAGF,MAAM,aAAa,MAAM,YAAY,IAAI,aAAa,YAAY;AAClE,QAAM;EACN,MAAM,mBAAmB,OAAO,cAAc,cAAc,KAAK;EACjE,MAAM,gBAAgB,OAAO,cAAc,WAAW,KAAK;AAC3D,eAAa;AACX,qBAAkB;AAClB,kBAAe;;GAEjB;;AAGJ,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,eAAe;CAC7B,OAAO;CACR,CAAC"}
+{"version":3,"file":"track-current-time.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/track-current-time.ts"],"sourcesContent":["/**\n * Mirror `mediaElement.currentTime` into reactive state. Listens for:\n * - `timeupdate` — fires during playback (~4 Hz)\n * - `seeking` — fires when a seek begins; per spec, `currentTime` is already\n *   at the new position when this event dispatches, so buffer management can\n *   react immediately rather than waiting for `timeupdate`, which does not\n *   fire while paused.\n * - `emptied` — fires when the resource selection algorithm tears down the\n *   current media (e.g. a new `src` is set on the same element). Re-syncs so\n *   downstream state doesn't retain the stale playback position from the\n *   previous source when the engine is reused across src changes.\n *\n * Also syncs immediately when a media element becomes available.\n *\n * When no media element is attached, writes `config.defaultCurrentTime`\n * (default-default `0`, matching the HTMLMediaElement spec) so consumers\n * always see a defined position. Read-only mirror; does not push\n * `state.currentTime` back to the element.\n */\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\n\nexport interface CurrentTimeState {\n  currentTime?: number;\n}\n\nexport interface CurrentTimeContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface TrackCurrentTimeConfig {\n  /**\n   * Value written to `state.currentTime` when no media element is attached.\n   * Defaults to `0` — the HTMLMediaElement spec default.\n   */\n  defaultCurrentTime?: number;\n}\n\nfunction trackCurrentTimeSetup({\n  state,\n  context,\n  config,\n}: {\n  state: { currentTime: Signal<CurrentTimeState['currentTime']> };\n  context: { mediaElement: ReadonlySignal<CurrentTimeContext['mediaElement']> };\n  config?: TrackCurrentTimeConfig;\n}): () => void {\n  const defaultCurrentTime = config?.defaultCurrentTime ?? 0;\n\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) {\n      state.currentTime.set(defaultCurrentTime);\n      return;\n    }\n\n    const sync = () => state.currentTime.set(mediaElement.currentTime);\n    sync();\n    const removeEmptied = listen(mediaElement, 'emptied', sync);\n    const removeTimeupdate = listen(mediaElement, 'timeupdate', sync);\n    const removeSeeking = listen(mediaElement, 'seeking', sync);\n    return () => {\n      removeEmptied();\n      removeTimeupdate();\n      removeSeeking();\n    };\n  });\n}\n\nexport const trackCurrentTime = defineBehavior({\n  stateKeys: ['currentTime'],\n  contextKeys: ['mediaElement'],\n  setup: trackCurrentTimeSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAS,sBAAsB,EAC7B,OACA,SACA,UAKa;CACb,MAAM,qBAAqB,QAAQ,sBAAsB;AAEzD,QAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,KAAK;AAC/C,MAAI,CAAC,cAAc;AACjB,SAAM,YAAY,IAAI,mBAAmB;AACzC;;EAGF,MAAM,aAAa,MAAM,YAAY,IAAI,aAAa,YAAY;AAClE,QAAM;EACN,MAAM,gBAAgB,OAAO,cAAc,WAAW,KAAK;EAC3D,MAAM,mBAAmB,OAAO,cAAc,cAAc,KAAK;EACjE,MAAM,gBAAgB,OAAO,cAAc,WAAW,KAAK;AAC3D,eAAa;AACX,kBAAe;AACf,qBAAkB;AAClB,kBAAe;;GAEjB;;AAGJ,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,eAAe;CAC7B,OAAO;CACR,CAAC"}

package/dist/default/playback/behaviors/dom/update-mediasource-duration.js

@@ -1,8 +1,8 @@
 import { computed } from "../../../core/signals/primitives.js";
 import { defineBehavior } from "../../../core/composition/create-composition.js";
 import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
-import { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
 import { waitForMediaSourceOpen } from "../../../media/dom/mse/mediasource-setup.js";
+import { getMaxBufferedEnd, shouldUpdateDuration, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
 //#region src/playback/behaviors/dom/update-mediasource-duration.ts
 /**
 * **Propagate `presentation.duration` to `mediaSource.duration` — exactly

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

@@ -3,12 +3,13 @@ import { defineBehavior } from "../../core/composition/create-composition.js";
 import { ConcurrentRunner, Task } from "../../core/tasks/task.js";
 import { createMachineReactor } from "../../core/reactors/create-machine-reactor.js";
 import { isResolvedPresentation, isResolvedTrack } from "../../media/types/index.js";
-import { findTrack, updateTrackInPresentation } from "../../media/utils/tracks.js";
-import { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "./track-types.js";
-import { fetchResolvable, getResponseText } from "../../network/fetch.js";
-import { parseMediaPlaylist } from "../../media/hls/parse-media-playlist.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 { fetchResolvableText } from "../../network/fetch.js";
+import { failoverFetch } from "../primitives/failover-fetch.js";
 //#region src/playback/behaviors/resolve-track.ts
-function setupTrackResolution({ state, config: { selectedKey, findTrackToResolve } }) {
+function setupTrackResolution({ state, config: { selectedKey, findTrackToResolve, fetchResolvableText: fetchResolvableText$1 = fetchResolvableText } }) {
 	const runner = new ConcurrentRunner();
 	const derivedStateSignal = computed(() => isResolvedPresentation(state.presentation.get()) ? "presentation-resolved" : "presentation-unresolved");
 	return createMachineReactor({
@@ -25,8 +26,12 @@ function setupTrackResolution({ state, config: { selectedKey, findTrackToResolve
 					const track = findTrackToResolve(presentation, trackId);
 					if (!track || isResolvedTrack(track)) return;
 					runner.schedule(new Task(async (signal) => {
-						const mediaTrack = parseMediaPlaylist(await getResponseText(await fetchResolvable(track, { signal })), track);
-						update(state.presentation, (current) => isResolvedPresentation(current) ? updateTrackInPresentation(current, mediaTrack) : current);
+						const mediaTrack = parseMediaPlaylist(await fetchResolvableText$1(track, { signal }), track);
+						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;
+						});
 					}, { id: track.id }));
 				}]
 			}
@@ -53,13 +58,19 @@ const TEXT_TRACK_RESOLUTION_CONFIG = {
 const resolveVideoTrack = defineBehavior({
 	stateKeys: ["presentation", "selectedVideoTrackId"],
 	contextKeys: [],
-	setup: ({ state, config = {} }) => setupTrackResolution({
-		state,
-		config: {
+	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`,
@@ -68,13 +79,19 @@ const resolveVideoTrack = defineBehavior({
 const resolveAudioTrack = defineBehavior({
 	stateKeys: ["presentation", "selectedAudioTrackId"],
 	contextKeys: [],
-	setup: ({ state, config = {} }) => setupTrackResolution({
-		state,
-		config: {
+	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`,
@@ -83,13 +100,19 @@ const resolveAudioTrack = defineBehavior({
 const resolveTextTrack = defineBehavior({
 	stateKeys: ["presentation", "selectedTextTrackId"],
 	contextKeys: [],
-	setup: ({ state, config = {} }) => setupTrackResolution({
-		state,
-		config: {
+	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 };

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

@@ -1 +1 @@
-{"version":3,"file":"resolve-track.js","names":[],"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 { ConcurrentRunner, Task } from '../../core/tasks/task';\nimport { parseMediaPlaylist } from '../../media/hls/parse-media-playlist';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTrack, ResolvedTrack } from '../../media/types';\nimport { isResolvedPresentation, isResolvedTrack } from '../../media/types';\nimport { findTrack, updateTrackInPresentation } from '../../media/utils/tracks';\nimport { fetchResolvable, getResponseText } from '../../network/fetch';\nimport { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from './track-types';\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}\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\ninterface TrackResolutionConfig<K extends SelectedTrackKey> {\n  selectedKey: K;\n  findTrackToResolve: (\n    presentation: MaybeResolvedPresentation,\n    trackId: string\n  ) => PartiallyResolvedTrack | ResolvedTrack | undefined;\n}\n\nfunction setupTrackResolution<K extends SelectedTrackKey>({\n  state,\n  config: { selectedKey, findTrackToResolve },\n}: {\n  state: ResolveTrackStateMap<K>;\n  config: TrackResolutionConfig<K>;\n}) {\n  // NOTE: This can/maybe will be pulled into a per-use case factory (e.g. something like createTaskRunner() with args TBD),\n  // likely eventually passed down via config or a new \"definitions\" argument. This will allow us to decide if we want our task runner/scheduler\n  // to e.g. run concurrently (like we currently are), serially with a queue, or abort the previous task and replace it with the newly scheduled one. (CJP).\n  const runner = new ConcurrentRunner();\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) don't\n            // 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            if (!track || isResolvedTrack(track)) return;\n\n            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              new Task(\n                async (signal) => {\n                  const response = await fetchResolvable(track, { signal });\n                  const text = await getResponseText(response);\n                  const mediaTrack = parseMediaPlaylist(text, track);\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                    isResolvedPresentation(current) ? updateTrackInPresentation(current, mediaTrack) : current\n                  );\n                },\n                { id: track.id }\n              )\n            );\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: ({ state, config = {} }: { state: ResolveTrackStateMap<'selectedVideoTrackId'>; config?: object }) =>\n    setupTrackResolution({\n      state,\n      config: { ...VIDEO_TRACK_RESOLUTION_CONFIG, ...config },\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: ({ state, config = {} }: { state: ResolveTrackStateMap<'selectedAudioTrackId'>; config?: object }) =>\n    setupTrackResolution({\n      state,\n      config: { ...AUDIO_TRACK_RESOLUTION_CONFIG, ...config },\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: ({ state, config = {} }: { state: ResolveTrackStateMap<'selectedTextTrackId'>; config?: object }) =>\n    setupTrackResolution({\n      state,\n      config: { ...TEXT_TRACK_RESOLUTION_CONFIG, ...config },\n    }),\n});\n"],"mappings":";;;;;;;;;;AA+CA,SAAS,qBAAiD,EACxD,OACA,QAAQ,EAAE,aAAa,wBAItB;CAID,MAAM,SAAS,IAAI,kBAAkB;CAWrC,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,KAAK,CAAC,GAC3C,0BACA,0BACN;AAED,QAAO,qBAAqB;EAC1B,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,2BAA2B,EAAE;GAC7B,yBAAyB;IAOvB,mBAAmB,OAAO,UAAU;IACpC,SAAS,OACD;KAMJ,MAAM,eAAe,KAAK,MAAM,aAAa;KAC7C,MAAM,UAAU,MAAM,aAAa,KAAK;AACxC,SAAI,CAAC,gBAAgB,CAAC,QAAS;KAE/B,MAAM,QAAQ,mBAAmB,cAAc,QAAQ;AACvD,SAAI,CAAC,SAAS,gBAAgB,MAAM,CAAE;AAEtC,YAAO,SAGL,IAAI,KACF,OAAO,WAAW;MAGhB,MAAM,aAAa,mBADN,MAAM,gBADF,MAAM,gBAAgB,OAAO,EAAE,QAAQ,CAAC,CACb,EACA,MAAM;AASlD,aAAO,MAAM,eAAe,YAC1B,uBAAuB,QAAQ,GAAG,0BAA0B,SAAS,WAAW,GAAG,QACpF;QAEH,EAAE,IAAI,MAAM,IAAI,CACjB,CACF;MAEJ;IACF;GACF;EACF,CAAC;;AAOJ,MAAM,gCAAgC;CACpC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,SAAS,QAAQ;CAC5C;AAED,MAAM,gCAAgC;CACpC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,SAAS,QAAQ;CAC5C;AAED,MAAM,+BAA+B;CACnC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,QAAQ,QAAQ;CAC3C;;;;;;AAWD,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa,EAAE;CACf,QAAQ,EAAE,OAAO,SAAS,EAAE,OAC1B,qBAAqB;EACnB;EACA,QAAQ;GAAE,GAAG;GAA+B,GAAG;GAAQ;EACxD,CAAC;CACL,CAAC;;;;;AAMF,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa,EAAE;CACf,QAAQ,EAAE,OAAO,SAAS,EAAE,OAC1B,qBAAqB;EACnB;EACA,QAAQ;GAAE,GAAG;GAA+B,GAAG;GAAQ;EACxD,CAAC;CACL,CAAC;;;;;AAMF,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,EAAE;CACf,QAAQ,EAAE,OAAO,SAAS,EAAE,OAC1B,qBAAqB;EACnB;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;GAAQ;EACvD,CAAC;CACL,CAAC"}
+{"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 { ConcurrentRunner, 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 { 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 { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../primitives/track-types';\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\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}\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}\n\nfunction setupTrackResolution<K extends SelectedTrackKey>({\n  state,\n  config: { selectedKey, findTrackToResolve, fetchResolvableText = defaultFetchResolvableText },\n}: {\n  state: ResolveTrackStateMap<K>;\n  config: TrackResolutionConfig<K>;\n}) {\n  // NOTE: This can/maybe will be pulled into a per-use case factory (e.g. something like createTaskRunner() with args TBD),\n  // likely eventually passed down via config or a new \"definitions\" argument. This will allow us to decide if we want our task runner/scheduler\n  // to e.g. run concurrently (like we currently are), serially with a queue, or abort the previous task and replace it with the newly scheduled one. (CJP).\n  const runner = new ConcurrentRunner();\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) don't\n            // 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            if (!track || isResolvedTrack(track)) return;\n\n            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              new Task(\n                async (signal) => {\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.\n                  const text = await fetchResolvableText(track, { signal });\n                  const mediaTrack = parseMediaPlaylist(text, track);\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                    return NON_FMP4_CONTAINER_MIMES.has(mediaTrack.mimeType)\n                      ? applyContainerMimeType(patched, mediaTrack.type, mediaTrack.mimeType)\n                      : patched;\n                  });\n                },\n                { id: track.id }\n              )\n            );\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":";;;;;;;;;;;AA6DA,SAAS,qBAAiD,EACxD,OACA,QAAQ,EAAE,aAAa,oBAAoB,qBAAA,wBAAsBA,yBAIhE;CAID,MAAM,SAAS,IAAI,kBAAkB;CAWrC,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,KAAK,CAAC,GAC3C,0BACA,0BACN;AAED,QAAO,qBAAqB;EAC1B,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,2BAA2B,EAAE;GAC7B,yBAAyB;IAOvB,mBAAmB,OAAO,UAAU;IACpC,SAAS,OACD;KAMJ,MAAM,eAAe,KAAK,MAAM,aAAa;KAC7C,MAAM,UAAU,MAAM,aAAa,KAAK;AACxC,SAAI,CAAC,gBAAgB,CAAC,QAAS;KAE/B,MAAM,QAAQ,mBAAmB,cAAc,QAAQ;AACvD,SAAI,CAAC,SAAS,gBAAgB,MAAM,CAAE;AAEtC,YAAO,SAGL,IAAI,KACF,OAAO,WAAW;MAMhB,MAAM,aAAa,mBADN,MAAMC,sBAAoB,OAAO,EAAE,QAAQ,CAAC,EACb,MAAM;AASlD,aAAO,MAAM,eAAe,YAAY;AACtC,WAAI,CAAC,uBAAuB,QAAQ,CAAE,QAAO;OAC7C,MAAM,UAAU,0BAA0B,SAAS,WAAW;AAS9D,cAAO,yBAAyB,IAAI,WAAW,SAAS,GACpD,uBAAuB,SAAS,WAAW,MAAM,WAAW,SAAS,GACrE;QACJ;QAEJ,EAAE,IAAI,MAAM,IAAI,CACjB,CACF;MAEJ;IACF;GACF;EACF,CAAC;;AAOJ,MAAM,gCAAgC;CACpC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,SAAS,QAAQ;CAC5C;AAED,MAAM,gCAAgC;CACpC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,SAAS,QAAQ;CAC5C;AAED,MAAM,+BAA+B;CACnC,GAAG;CACH,qBAAqB,cAAyC,YAC5D,UAAU,cAAc,QAAQ,QAAQ;CAC3C;;;;;;AAWD,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa,EAAE;CACf,QAAQ,EACN,OACA,SAAS,EAAE,OAIP;EAMJ,MAAM,cAAc;GAAE,GAAG;GAA+B,GAAG;GAAQ;AACnE,SAAO,qBAAqB;GAC1B;GACA,QAAQ;IAAE,GAAG;IAAa,qBAAqB,cAAcD,qBAA4B,OAAO,YAAY;IAAE;GAC/G,CAAC;;CAEL,CAAC;;;;;AAMF,MAAa,oBAAoB,eAAe;CAC9C,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa,EAAE;CACf,QAAQ,EACN,OACA,SAAS,EAAE,OAIP;EAEJ,MAAM,cAAc;GAAE,GAAG;GAA+B,GAAG;GAAQ;AACnE,SAAO,qBAAqB;GAC1B;GACA,QAAQ;IAAE,GAAG;IAAa,qBAAqB,cAAcA,qBAA4B,OAAO,YAAY;IAAE;GAC/G,CAAC;;CAEL,CAAC;;;;;AAMF,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,EAAE;CACf,QAAQ,EACN,OACA,SAAS,EAAE,OAIP;EAEJ,MAAM,cAAc;GAAE,GAAG;GAA8B,GAAG;GAAQ;AAClE,SAAO,qBAAqB;GAC1B;GACA,QAAQ;IAAE,GAAG;IAAa,qBAAqB,cAAcA,qBAA4B,OAAO,YAAY;IAAE;GAC/G,CAAC;;CAEL,CAAC"}

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

@@ -2,34 +2,41 @@ import { computed } 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 { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "./track-types.js";
-import { pickFirstTrackId, pickTextTrack } from "../../media/primitives/select-tracks.js";
+import { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../primitives/track-types.js";
+import { pickAudioTrack, pickFirstTrackId } from "../../media/primitives/select-tracks.js";
 //#region src/playback/behaviors/select-tracks.ts
 /**
-* **Default audio/text track selection on src load / unselect on src unload.**
-* When a presentation is resolved, sets `selectedAudioTrackId` /
-* `selectedTextTrackId` to a per-type-picker default 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.
+* **Default audio/video track selection on src load / unselect on src unload.**
+* When a presentation is resolved, sets `selectedVideoTrackId` /
+* `selectedAudioTrackId` to a per-type-picker default 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: each transition fires its work once. Does not police
-* the selection between transitions; external writes (user picks) are left
-* alone.
+* Lifecycle-driven: each transition fires its work once. Does not police the
+* selection between transitions; external writes (user picks, ABR, programmatic
+* filter-driven re-picks) are left alone.
 *
 * Picker is config-driven: each per-type export wires a sensible default
-* (`pickFirstTrackId` for audio, `pickTextTrack` for text) and the caller
-* can supply their own via `config.picker` for custom selection logic
-* (language preferences, default-track handling, etc.). The behavior's
-* `config` is forwarded to the picker as its second argument, so options
-* like `preferredAudioLanguage` / `preferredSubtitleLanguage` reach the
-* picker without an intermediate wrapping layer.
+* (`pickAudioTrack` for audio — three-tier language-aware; `pickFirstTrackId`
+* for video) and the caller can supply their own via `config.picker` for custom
+* selection logic. The behavior's `config` is forwarded to the picker as its
+* second argument, so options like `preferredAudioLanguage` reach the picker
+* without an intermediate wrapping layer.
 *
 * Compose `selectVideoTrack` for the simple "pick a default video track"
-* behavior, or `switchVideoQuality` (`./quality-switching.ts`) for the
-* ABR-driven variant — they're alternatives, not stackable (both write
-* `selectedVideoTrackId`). The simple variant tree-shakes out the
-* ABR machinery (bandwidth-estimator, quality-selection algorithms).
+* 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, picker, pickerConfig } }) {
 	const derivedStateSignal = computed(() => isResolvedPresentation(state.presentation.get()) ? "presentation-resolved" : "presentation-unresolved");
@@ -50,83 +57,45 @@ function setupTrackSelection({ state, config: { selectedKey, picker, pickerConfi
 }
 /** Default video picker: first track in the video selection set. */
 const defaultVideoPicker = (presentation) => pickFirstTrackId(presentation, "video");
-const VIDEO_TRACK_SELECTION_CONFIG = {
-	...VIDEO_TYPE_CONFIG,
-	picker: defaultVideoPicker
-};
-/** Default audio picker: first track in the audio selection set. */
-const defaultAudioPicker = (presentation) => pickFirstTrackId(presentation, "audio");
-const AUDIO_TRACK_SELECTION_CONFIG = {
-	...AUDIO_TYPE_CONFIG,
-	picker: defaultAudioPicker
-};
-const TEXT_TRACK_SELECTION_CONFIG = {
-	...TEXT_TYPE_CONFIG,
-	picker: pickTextTrack
-};
-defineBehavior({
-	stateKeys: ["presentation", "selectedVideoTrackId"],
-	contextKeys: [],
-	setup: ({ state, config }) => setupTrackSelection({
-		state,
-		config: {
-			...VIDEO_TRACK_SELECTION_CONFIG,
-			picker: config?.picker ?? VIDEO_TRACK_SELECTION_CONFIG.picker,
-			pickerConfig: config
-		}
-	})
-});
 /**
-* Select an audio track when a presentation loads. Clears the selection
-* on src unload.
+* Select a video track when a presentation loads. Clears the selection on
+* src unload.
 *
-* @example
-* const reactor = selectAudioTrack.setup({ state });
+* 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
-* // Custom picker with language preference
-* const reactor = selectAudioTrack.setup({
-*   state,
-*   config: { preferredAudioLanguage: 'en', picker: myLanguageAwarePicker },
-* });
+* const reactor = selectVideoTrack.setup({ state });
 */
-const selectAudioTrack = defineBehavior({
-	stateKeys: ["presentation", "selectedAudioTrackId"],
+const selectVideoTrack = defineBehavior({
+	stateKeys: ["presentation", "selectedVideoTrackId"],
 	contextKeys: [],
 	setup: ({ state, config }) => setupTrackSelection({
 		state,
 		config: {
-			...AUDIO_TRACK_SELECTION_CONFIG,
-			picker: config?.picker ?? AUDIO_TRACK_SELECTION_CONFIG.picker,
+			selectedKey: VIDEO_TYPE_CONFIG.selectedKey,
+			picker: config?.picker ?? defaultVideoPicker,
 			pickerConfig: config
 		}
 	})
 });
-/**
-* Select a text track based on user preferences (preferred language,
-* default-track auto-select, forced-track filtering). Clears the selection
-* on src unload.
-*
-* Unlike audio selection, the default text picker returns `undefined` when
-* no preference matches, leaving the selection unset — text-track
-* selection is user opt-in.
-*
-* @example
-* const reactor = selectTextTrack.setup({ state, config: { preferredSubtitleLanguage: 'en' } });
-*/
-const selectTextTrack = defineBehavior({
-	stateKeys: ["presentation", "selectedTextTrackId"],
+defineBehavior({
+	stateKeys: ["presentation", "selectedAudioTrackId"],
 	contextKeys: [],
 	setup: ({ state, config }) => setupTrackSelection({
 		state,
 		config: {
-			...TEXT_TRACK_SELECTION_CONFIG,
-			picker: config?.picker ?? TEXT_TRACK_SELECTION_CONFIG.picker,
+			selectedKey: AUDIO_TYPE_CONFIG.selectedKey,
+			picker: config?.picker ?? pickAudioTrack,
 			pickerConfig: config
 		}
 	})
 });
 //#endregion
-export { selectAudioTrack, selectTextTrack };
+export { selectVideoTrack };
 
 //# sourceMappingURL=select-tracks.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"select-tracks.js","names":[],"sources":["../../../../src/playback/behaviors/select-tracks.ts"],"sourcesContent":["/**\n * **Default audio/text track selection on src load / unselect on src unload.**\n * When a presentation is resolved, sets `selectedAudioTrackId` /\n * `selectedTextTrackId` to a per-type-picker default if no selection already\n * exists. When the presentation is unset/reset (transitions back to\n * unresolved), clears the selection so a stale id from the previous source\n * doesn't persist.\n *\n * Lifecycle-driven: each transition fires its work once. Does not police\n * the selection between transitions; external writes (user picks) are left\n * alone.\n *\n * Picker is config-driven: each per-type export wires a sensible default\n * (`pickFirstTrackId` for audio, `pickTextTrack` for text) and the caller\n * can supply their own via `config.picker` for custom selection logic\n * (language preferences, default-track handling, etc.). The behavior's\n * `config` is forwarded to the picker as its second argument, so options\n * like `preferredAudioLanguage` / `preferredSubtitleLanguage` reach the\n * picker without an intermediate wrapping layer.\n *\n * Compose `selectVideoTrack` for the simple \"pick a default video track\"\n * behavior, or `switchVideoQuality` (`./quality-switching.ts`) for the\n * ABR-driven variant — they're alternatives, not stackable (both write\n * `selectedVideoTrackId`). The simple variant tree-shakes out the\n * ABR machinery (bandwidth-estimator, quality-selection algorithms).\n */\n\nimport { defineBehavior } from '../../core/composition/create-composition';\nimport { createMachineReactor } from '../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport {\n  type AudioSelectionConfig,\n  pickFirstTrackId,\n  pickTextTrack,\n  type TextSelectionConfig,\n  type TrackPicker,\n  type TrackSelectionState,\n  type VideoSelectionConfig,\n} from '../../media/primitives/select-tracks';\nimport { isResolvedPresentation } from '../../media/types';\nimport { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from './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`, default picker, and forwarded picker 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' | 'selectedTextTrackId';\n\ntype SelectStateMap<K extends SelectedTrackKey> = {\n  presentation: ReadonlySignal<TrackSelectionState['presentation']>;\n} & { [P in K]: Signal<TrackSelectionState[P]> };\n\ninterface TrackSelectionSetupConfig<K extends SelectedTrackKey, PickerConfig> {\n  selectedKey: K;\n  picker: TrackPicker<PickerConfig>;\n  pickerConfig?: PickerConfig;\n}\n\nfunction setupTrackSelection<K extends SelectedTrackKey, PickerConfig>({\n  state,\n  config: { selectedKey, picker, pickerConfig },\n}: {\n  state: SelectStateMap<K>;\n  config: TrackSelectionSetupConfig<K, PickerConfig>;\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        // 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            const id = picker(state.presentation.get()!, pickerConfig);\n            if (id) state[selectedKey].set(id);\n          }\n          return () => state[selectedKey].set(undefined);\n        },\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Per-helper-per-type configs — defaults that variants spread engine config over\n//\n// The engine-facing config carries `picker?` (optional override) plus\n// fields the default picker consults (preferred language, etc.). The\n// variant resolves the final picker (engine override or default) and\n// forwards the whole engine config as `pickerConfig` so rich pickers can\n// read their options.\n// ============================================================================\n\n/** Default video picker: first track in the video selection set. */\nconst defaultVideoPicker: TrackPicker = (presentation) => pickFirstTrackId(presentation, 'video');\n\nconst VIDEO_TRACK_SELECTION_CONFIG = {\n  ...VIDEO_TYPE_CONFIG,\n  picker: defaultVideoPicker,\n} as const;\n\n/** Default audio picker: first track in the audio selection set. */\nconst defaultAudioPicker: TrackPicker = (presentation) => pickFirstTrackId(presentation, 'audio');\n\nconst AUDIO_TRACK_SELECTION_CONFIG = {\n  ...AUDIO_TYPE_CONFIG,\n  picker: defaultAudioPicker,\n} as const;\n\nconst TEXT_TRACK_SELECTION_CONFIG = {\n  ...TEXT_TYPE_CONFIG,\n  picker: pickTextTrack,\n} as const;\n\n// ============================================================================\n// Specialized exports — one per track type\n// ============================================================================\n\n/**\n * Config for `selectVideoTrack`. Pass `picker` to fully override selection\n * logic; otherwise the default `pickFirstTrackId` is used.\n */\nexport interface SelectVideoTrackConfig extends Omit<VideoSelectionConfig, 'type'> {\n  picker?: TrackPicker<SelectVideoTrackConfig>;\n}\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 `switchVideoQuality` — 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        ...VIDEO_TRACK_SELECTION_CONFIG,\n        picker: config?.picker ?? VIDEO_TRACK_SELECTION_CONFIG.picker,\n        pickerConfig: config,\n      },\n    }),\n});\n\n/**\n * Config for `selectAudioTrack`. Pass `picker` to fully override selection\n * logic; otherwise the default `pickFirstTrackId` is used (which ignores\n * the other fields — they reach the picker as its second arg for callers\n * who supply a richer picker, like a language-aware one).\n */\nexport interface SelectAudioTrackConfig extends Omit<AudioSelectionConfig, 'type'> {\n  picker?: TrackPicker<SelectAudioTrackConfig>;\n}\n\n/**\n * Select an audio track when a presentation loads. Clears the selection\n * on src unload.\n *\n * @example\n * const reactor = selectAudioTrack.setup({ state });\n *\n * @example\n * // Custom picker with language preference\n * const reactor = selectAudioTrack.setup({\n *   state,\n *   config: { preferredAudioLanguage: 'en', picker: myLanguageAwarePicker },\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        ...AUDIO_TRACK_SELECTION_CONFIG,\n        picker: config?.picker ?? AUDIO_TRACK_SELECTION_CONFIG.picker,\n        pickerConfig: config,\n      },\n    }),\n});\n\n/**\n * Config for `selectTextTrack`. Pass `picker` to fully override selection\n * logic; otherwise the default `pickTextTrack` is used, which honors the\n * other fields.\n */\nexport interface SelectTextTrackConfig extends TextSelectionConfig {\n  picker?: TrackPicker<SelectTextTrackConfig>;\n}\n\n/**\n * Select a text track based on user preferences (preferred language,\n * default-track auto-select, forced-track filtering). Clears the selection\n * on src unload.\n *\n * Unlike audio selection, the default text picker returns `undefined` when\n * no preference matches, leaving the selection unset — text-track\n * selection is user opt-in.\n *\n * @example\n * const reactor = selectTextTrack.setup({ state, config: { preferredSubtitleLanguage: 'en' } });\n */\nexport const selectTextTrack = defineBehavior({\n  stateKeys: ['presentation', 'selectedTextTrackId'],\n  contextKeys: [],\n  setup: ({ state, config }: { state: SelectStateMap<'selectedTextTrackId'>; config?: SelectTextTrackConfig }) =>\n    setupTrackSelection({\n      state,\n      config: {\n        ...TEXT_TRACK_SELECTION_CONFIG,\n        picker: config?.picker ?? TEXT_TRACK_SELECTION_CONFIG.picker,\n        pickerConfig: config,\n      },\n    }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,SAAS,oBAA8D,EACrE,OACA,QAAQ,EAAE,aAAa,QAAQ,kBAI9B;CACD,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,KAAK,CAAC,GAC3C,0BACA,0BACN;AAED,QAAO,qBAAqB;EAC1B,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,2BAA2B,EAAE;GAC7B,yBAAyB,EAYvB,aAAa;AACX,QAAI,CAAC,MAAM,aAAa,KAAK,EAAE;KAK7B,MAAM,KAAK,OAAO,MAAM,aAAa,KAAK,EAAG,aAAa;AAC1D,SAAI,GAAI,OAAM,aAAa,IAAI,GAAG;;AAEpC,iBAAa,MAAM,aAAa,IAAI,KAAA,EAAU;MAEjD;GACF;EACF,CAAC;;;AAcJ,MAAM,sBAAmC,iBAAiB,iBAAiB,cAAc,QAAQ;AAEjG,MAAM,+BAA+B;CACnC,GAAG;CACH,QAAQ;CACT;;AAGD,MAAM,sBAAmC,iBAAiB,iBAAiB,cAAc,QAAQ;AAEjG,MAAM,+BAA+B;CACnC,GAAG;CACH,QAAQ;CACT;AAED,MAAM,8BAA8B;CAClC,GAAG;CACH,QAAQ;CACT;AA4B+B,eAAe;CAC7C,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa,EAAE;CACf,QAAQ,EAAE,OAAO,aACf,oBAAoB;EAClB;EACA,QAAQ;GACN,GAAG;GACH,QAAQ,QAAQ,UAAU,6BAA6B;GACvD,cAAc;GACf;EACF,CAAC;CACL,CAAC;;;;;;;;;;;;;;;AA0BF,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa,EAAE;CACf,QAAQ,EAAE,OAAO,aACf,oBAAoB;EAClB;EACA,QAAQ;GACN,GAAG;GACH,QAAQ,QAAQ,UAAU,6BAA6B;GACvD,cAAc;GACf;EACF,CAAC;CACL,CAAC;;;;;;;;;;;;;AAuBF,MAAa,kBAAkB,eAAe;CAC5C,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa,EAAE;CACf,QAAQ,EAAE,OAAO,aACf,oBAAoB;EAClB;EACA,QAAQ;GACN,GAAG;GACH,QAAQ,QAAQ,UAAU,4BAA4B;GACtD,cAAc;GACf;EACF,CAAC;CACL,CAAC"}
+{"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` to a per-type-picker default if no selection already\n * 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: each transition fires its work once. Does not police the\n * selection between transitions; external writes (user picks, ABR, programmatic\n * filter-driven re-picks) are left alone.\n *\n * Picker is config-driven: each per-type export wires a sensible default\n * (`pickAudioTrack` for audio — three-tier language-aware; `pickFirstTrackId`\n * for video) and the caller can supply their own via `config.picker` for custom\n * selection logic. The behavior's `config` is forwarded to the picker as its\n * second argument, so options like `preferredAudioLanguage` reach the picker\n * without an intermediate wrapping layer.\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, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport {\n  type AudioSelectionConfig,\n  pickAudioTrack,\n  pickFirstTrackId,\n  type TrackPicker,\n  type TrackSelectionState,\n  type VideoSelectionConfig,\n} from '../../media/primitives/select-tracks';\nimport { isResolvedPresentation } from '../../media/types';\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`, default picker, and forwarded picker 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\ninterface TrackSelectionSetupConfig<K extends SelectedTrackKey, PickerConfig> {\n  selectedKey: K;\n  picker: TrackPicker<PickerConfig>;\n  pickerConfig?: PickerConfig;\n}\n\nfunction setupTrackSelection<K extends SelectedTrackKey, PickerConfig>({\n  state,\n  config: { selectedKey, picker, pickerConfig },\n}: {\n  state: SelectStateMap<K>;\n  config: TrackSelectionSetupConfig<K, PickerConfig>;\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        // 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            const id = picker(state.presentation.get()!, pickerConfig);\n            if (id) state[selectedKey].set(id);\n          }\n          return () => state[selectedKey].set(undefined);\n        },\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Default pickers\n//\n// Each variant resolves its picker as `config?.picker ?? <default>` and\n// forwards the whole engine config as `pickerConfig`, so a rich picker\n// (`pickAudioTrack`) reads its options directly. Audio uses its primitive\n// picker as-is; video adapts `pickFirstTrackId` (positional `type` arg) into\n// the `TrackPicker` shape.\n// ============================================================================\n\n/** Default video picker: first track in the video selection set. */\nconst defaultVideoPicker: TrackPicker = (presentation) => pickFirstTrackId(presentation, 'video');\n\n// ============================================================================\n// Specialized exports — one per track type\n// ============================================================================\n\n/**\n * Config for `selectVideoTrack`. Pass `picker` to fully override selection\n * logic; otherwise the default `pickFirstTrackId` is used.\n */\nexport interface SelectVideoTrackConfig extends VideoSelectionConfig {\n  picker?: TrackPicker<SelectVideoTrackConfig>;\n}\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        picker: config?.picker ?? defaultVideoPicker,\n        pickerConfig: config,\n      },\n    }),\n});\n\n/**\n * Config for `selectAudioTrack`. Pass `picker` to fully override selection\n * logic; otherwise the default `pickAudioTrack` is used (three-tier:\n * `preferredAudioLanguage` → `DEFAULT=YES` → first track).\n */\nexport interface SelectAudioTrackConfig extends AudioSelectionConfig {\n  picker?: TrackPicker<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 * // Custom picker with language preference\n * const reactor = selectAudioTrack.setup({\n *   state,\n *   config: { preferredAudioLanguage: 'en', picker: myLanguageAwarePicker },\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        picker: config?.picker ?? pickAudioTrack,\n        pickerConfig: config,\n      },\n    }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,SAAS,oBAA8D,EACrE,OACA,QAAQ,EAAE,aAAa,QAAQ,kBAI9B;CACD,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,KAAK,CAAC,GAC3C,0BACA,0BACN;AAED,QAAO,qBAAqB;EAC1B,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,2BAA2B,EAAE;GAC7B,yBAAyB,EAYvB,aAAa;AACX,QAAI,CAAC,MAAM,aAAa,KAAK,EAAE;KAK7B,MAAM,KAAK,OAAO,MAAM,aAAa,KAAK,EAAG,aAAa;AAC1D,SAAI,GAAI,OAAM,aAAa,IAAI,GAAG;;AAEpC,iBAAa,MAAM,aAAa,IAAI,KAAA,EAAU;MAEjD;GACF;EACF,CAAC;;;AAcJ,MAAM,sBAAmC,iBAAiB,iBAAiB,cAAc,QAAQ;;;;;;;;;;;;;;;AA4BjG,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa,EAAE;CACf,QAAQ,EAAE,OAAO,aACf,oBAAoB;EAClB;EACA,QAAQ;GACN,aAAa,kBAAkB;GAC/B,QAAQ,QAAQ,UAAU;GAC1B,cAAc;GACf;EACF,CAAC;CACL,CAAC;AAkC8B,eAAe;CAC7C,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa,EAAE;CACf,QAAQ,EAAE,OAAO,aACf,oBAAoB;EAClB;EACA,QAAQ;GACN,aAAa,kBAAkB;GAC/B,QAAQ,QAAQ,UAAU;GAC1B,cAAc;GACf;EACF,CAAC;CACL,CAAC"}

package/dist/default/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 { setupFailoverMonitor };
+
+//# sourceMappingURL=setup-failover-monitor.js.map

package/dist/default/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,KACb;;;;;;;;AAmBD,MAAa,uBAAuB,eAAe;CACjD,WAAW,CAAC,gBAAgB,aAAa;CACzC,aAAa,EAAE;CACf,QAAQ,EACN,OACA,SAAS,EAAE,OAOP;EACJ,MAAM,aAAa,OAAO,UAAU,cAAc,gCAAgC;EAIlF,MAAM,yBAAS,IAAI,KAA4C;EAC/D,MAAM,qBAAqB,eACzB,uBAAuB,MAAM,aAAa,KAAK,CAAC,GAC3C,0BACA,0BACN;AAED,SAAO,qBAAqB;GAC1B,SAAS;GACT,eAAe,mBAAmB,KAAK;GACvC,QAAQ;IACN,2BAA2B,EAAE;IAC7B,yBAAyB;KAGvB,mBAAmB;AACjB,aAAO,SAAS,UAAU,aAAa,MAAM,CAAC;AAC9C,aAAO,OAAO;AACd,YAAM,WAAW,IAAI,KAAA,EAAU;;KAEjC,SAAS,OACD;AAEJ,OADe,MAAM,WAAW,KAAK,IAAI,EAAE,EACpC,SAAS,QAAQ;AAGtB,WAAI,OAAO,IAAI,IAAI,CAAE;OACrB,MAAM,QAAQ,iBAAiB;AAC7B,eAAO,OAAO,IAAI;AAClB,eAAO,MAAM,aAAa,YAAY,SAAS,QAAQ,MAAM,MAAM,IAAI,CAAC;UACvE,WAAW;AACd,cAAO,IAAI,KAAK,MAAM;QACtB;OAEL;KACF;IACF;GACF,CAAC;;CAEL,CAAC"}