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

package/dist/dev/playback/behaviors/dom/seek-to-live-edge.js

@@ -4,76 +4,58 @@ import { getLiveEdge } from "../../primitives/live-window.js";
 import { listen } from "@videojs/utils/dom";
 //#region src/playback/behaviors/dom/seek-to-live-edge.ts
 /**
-* Keep the playhead in the live window, via a two-state reactor gated on the
-* preconditions for "we know where live is":
+* Keep the playhead in the live window, via a two-state reactor gated on the preconditions for "we know where live is":
 *
-* - **`inactive`** — no media element, or no live edge (`getLiveEdge` is `null`:
-*   VOD, ended, or unresolved). Idle.
-* - **`live`** — preconditions met. `entry` commands `state.startPosition` once
-*   to the target live latency behind the edge (clamped to the window start) so
-*   playback begins near the edge and the loader dispatches an in-window range;
+* - **`inactive`** — no media element, or no live edge (`getLiveEdge` is `null`: VOD, ended, or unresolved). Idle.
+* - **`live`** — preconditions met. `entry` commands `state.startPosition` once to the target live latency behind the
+*   edge (clamped to the window start) so playback begins near the edge and the loader dispatches an in-window range;
 *   `effects` runs the window-exit guard.
 *
-* A derivable live edge is itself the establishment gate: segment placement is
-* settled at parse time — the reference track's local placement *is* the
-* presentation timeline, and every other track's first parse is held until the
-* anchor is stamped (`resolve-track`'s gate + `establishStartMediaTime`) — so
-* any window derived from resolved segments is already final, with no separate
-* anchor signal to wait on (see
+* A derivable live edge is itself the establishment gate: segment placement is settled at parse time — the reference
+* track's local placement _is_ the presentation timeline, and every other track's first parse is held until the anchor
+* is stamped (`resolve-track`'s gate + `establishStartMediaTime`) — so any window derived from resolved segments is
+* already final, with no separate anchor signal to wait on (see
 * `internal/design/spf/live-presentation-timeline-model.md`).
 *
-* The two pieces split along the axis a future DVR / EVENT mode will care about:
-* the **one-time start position** (`entry`) is the *live-specific* behavior — start
-* near the edge on load; a DVR mode makes it conditional (start in place). The
-* **window-exit guard** (`effects`) is the *general windowed-live* behavior —
-* applies to sliding-window live, DVR, and EVENT alike. Because the command is an
-* `entry`, it fires once per entry into `live`; a source change exits to
-* `inactive`, so the next source re-commands (no closure latch to reset). The
-* guard stays a direct seek — it is recurring, while `startPosition` is a
-* self-clearing one-shot.
+* The two pieces split along the axis a future DVR / EVENT mode will care about: the **one-time start position**
+* (`entry`) is the _live-specific_ behavior — start near the edge on load; a DVR mode makes it conditional (start in
+* place). The **window-exit guard** (`effects`) is the _general windowed-live_ behavior — applies to sliding-window
+* live, DVR, and EVENT alike. Because the command is an `entry`, it fires once per entry into `live`; a source change
+* exits to `inactive`, so the next source re-commands (no closure latch to reset). The guard stays a direct seek — it
+* is recurring, while `startPosition` is a self-clearing one-shot.
 *
-* Window-exit guard: while playing (not paused), reposition to the live edge
-* when the playhead has fallen behind the window start — including when a seek
-* to a now-evicted position has stranded the playhead (such a seek can never
-* settle, so we rescue rather than wait on it). Two triggers:
-* the **window-update re-fire** (the guard reads the live edge, so each reload /
-* slide re-runs it — this catches a stall, where `timeupdate` stops but the
-* playlist keeps reloading) and a **`play` listener** for immediate reactivity on
-* resume, since the reload interval can be seconds. `play`, not `playing`: after
-* a long pause the playhead sits behind the window at an unseekable position,
-* where the browser stalls and `playing` never fires; `play` fires on the
-* paused→false transition regardless, so we snap before the stall. In-window
-* pause / DVR scrub-back are left untouched.
+* Window-exit guard: while playing (not paused), reposition to the live edge when the playhead has fallen behind the
+* window start — including when a seek to a now-evicted position has stranded the playhead (such a seek can never
+* settle, so we rescue rather than wait on it). Two triggers: the **window-update re-fire** (the guard reads the live
+* edge, so each reload / slide re-runs it — this catches a stall, where `timeupdate` stops but the playlist keeps
+* reloading) and a **`play` listener** for immediate reactivity on resume, since the reload interval can be seconds.
+* `play`, not `playing`: after a long pause the playhead sits behind the window at an unseekable position, where the
+* browser stalls and `playing` never fires; `play` fires on the paused→false transition regardless, so we snap before
+* the stall. In-window pause / DVR scrub-back are left untouched.
 *
-* The latency comes from the injected `resolveLiveLatency` seam (HLS:
-* `HOLD-BACK`), so this behavior carries no delivery-format specifics.
-* `applyStartPosition` performs the seek, gated on `loadedmetadata` — which
-* implies an open MediaSource and hence a declared seekable range (a seek outside
-* `seekable` is clamped) — so this behavior needs no MediaSource precondition of
-* its own.
+* The latency comes from the injected `resolveLiveLatency` seam (HLS: `HOLD-BACK`), so this behavior carries no
+* delivery-format specifics. `applyStartPosition` performs the seek, gated on `loadedmetadata` — which implies an open
+* MediaSource and hence a declared seekable range (a seek outside `seekable` is clamped) — so this behavior needs no
+* MediaSource precondition of its own.
 */
 /**
-* Tolerance (seconds) around the window edges before the guard repositions, so
-* boundary / floating-point noise doesn't trigger a spurious seek.
+* Tolerance (seconds) around the window edges before the guard repositions, so boundary / floating-point noise doesn't
+* trigger a spurious seek.
 */
 const REPOSITION_TOLERANCE = .1;
 /**
-* `'live'` once the preconditions hold: a media element and a derivable live edge
-* (whose placement is final by construction — see the module docstring).
-* `'inactive'` otherwise.
+* `'live'` once the preconditions hold: a media element and a derivable live edge (whose placement is final by
+* construction — see the module docstring). `'inactive'` otherwise.
 *
-* Deliberately narrow: every signal here can flip the reactor out of and back into
-* `live`, re-firing `entry`. Neither blinks mid-source — the edge can't, because
-* `liveWindowForType` falls back to any resolved track of the type — so `entry`
-* fires once per source without a latch, and a live reload (same source, slid
-* window) correctly doesn't re-command.
+* Deliberately narrow: every signal here can flip the reactor out of and back into `live`, re-firing `entry`. Neither
+* blinks mid-source — the edge can't, because `liveWindowForType` falls back to any resolved track of the type — so
+* `entry` fires once per source without a latch, and a live reload (same source, slid window) correctly doesn't
+* re-command.
 *
-* The flip side: the presentation *url* is not part of this state, so replacing one
-* already-resolved live presentation with another would stay in `live` and never
-* command a start position for the new source. Unreachable today — every writer
-* sets `{ url }` (unresolved) or `undefined` first, so a source change always
-* transits `inactive`. Supporting a seeded pre-resolved presentation (via
-* `initialState`) that later changes would mean folding the url in here.
+* The flip side: the presentation _url_ is not part of this state, so replacing one already-resolved live presentation
+* with another would stay in `live` and never command a start position for the new source. Unreachable today — every
+* writer sets `{ url }` (unresolved) or `undefined` first, so a source change always transits `inactive`. Supporting a
+* seeded pre-resolved presentation (via `initialState`) that later changes would mean folding the url in here.
 */
 function deriveState(mediaElement, edge) {
 	return mediaElement && edge ? "live" : "inactive";
@@ -116,10 +98,9 @@ function seekToLiveEdgeSetup({ state, context, config }) {
 	});
 }
 /**
-* Manual `Behavior<>` literal (like `calculatePresentationDuration`): declares
-* only `presentation` + `startPosition` in stateKeys while reading
-* `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the
-* switch* behaviors), so it composes without a stateKeys/type conflict.
+* Manual `Behavior<>` literal (like `calculatePresentationDuration`): declares only `presentation` + `startPosition` in
+* stateKeys while reading `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the switch*
+* behaviors), so it composes without a stateKeys/type conflict.
 */
 const seekToLiveEdge = {
 	stateKeys: ["presentation", "startPosition"],

package/dist/dev/playback/behaviors/dom/seek-to-live-edge.js.map

@@ -1 +1 @@
-{"version":3,"file":"seek-to-live-edge.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/seek-to-live-edge.ts"],"sourcesContent":["/**\n * Keep the playhead in the live window, via a two-state reactor gated on the\n * preconditions for \"we know where live is\":\n *\n * - **`inactive`** — no media element, or no live edge (`getLiveEdge` is `null`:\n *   VOD, ended, or unresolved). Idle.\n * - **`live`** — preconditions met. `entry` commands `state.startPosition` once\n *   to the target live latency behind the edge (clamped to the window start) so\n *   playback begins near the edge and the loader dispatches an in-window range;\n *   `effects` runs the window-exit guard.\n *\n * A derivable live edge is itself the establishment gate: segment placement is\n * settled at parse time — the reference track's local placement *is* the\n * presentation timeline, and every other track's first parse is held until the\n * anchor is stamped (`resolve-track`'s gate + `establishStartMediaTime`) — so\n * any window derived from resolved segments is already final, with no separate\n * anchor signal to wait on (see\n * `internal/design/spf/live-presentation-timeline-model.md`).\n *\n * The two pieces split along the axis a future DVR / EVENT mode will care about:\n * the **one-time start position** (`entry`) is the *live-specific* behavior — start\n * near the edge on load; a DVR mode makes it conditional (start in place). The\n * **window-exit guard** (`effects`) is the *general windowed-live* behavior —\n * applies to sliding-window live, DVR, and EVENT alike. Because the command is an\n * `entry`, it fires once per entry into `live`; a source change exits to\n * `inactive`, so the next source re-commands (no closure latch to reset). The\n * guard stays a direct seek — it is recurring, while `startPosition` is a\n * self-clearing one-shot.\n *\n * Window-exit guard: while playing (not paused), reposition to the live edge\n * when the playhead has fallen behind the window start — including when a seek\n * to a now-evicted position has stranded the playhead (such a seek can never\n * settle, so we rescue rather than wait on it). Two triggers:\n * the **window-update re-fire** (the guard reads the live edge, so each reload /\n * slide re-runs it — this catches a stall, where `timeupdate` stops but the\n * playlist keeps reloading) and a **`play` listener** for immediate reactivity on\n * resume, since the reload interval can be seconds. `play`, not `playing`: after\n * a long pause the playhead sits behind the window at an unseekable position,\n * where the browser stalls and `playing` never fires; `play` fires on the\n * paused→false transition regardless, so we snap before the stall. In-window\n * pause / DVR scrub-back are left untouched.\n *\n * The latency comes from the injected `resolveLiveLatency` seam (HLS:\n * `HOLD-BACK`), so this behavior carries no delivery-format specifics.\n * `applyStartPosition` performs the seek, gated on `loadedmetadata` — which\n * implies an open MediaSource and hence a declared seekable range (a seek outside\n * `seekable` is clamped) — so this behavior needs no MediaSource precondition of\n * its own.\n */\nimport { listen } from '@videojs/utils/dom';\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor, type Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { getLiveEdge, type LiveEdge, type ResolveLiveLatency } from '../../primitives/live-window';\n\n/**\n * Tolerance (seconds) around the window edges before the guard repositions, so\n * boundary / floating-point noise doesn't trigger a spurious seek.\n */\nconst REPOSITION_TOLERANCE = 0.1;\n\nexport interface SeekToLiveEdgeState {\n  presentation?: MaybeResolvedPresentation;\n  /**\n   * One-shot start-position command in presentation-timeline seconds. Written\n   * here on entry into `live`; consumed (cleared) by `applyStartPosition`.\n   */\n  startPosition?: number;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\nexport interface SeekToLiveEdgeContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface SeekToLiveEdgeConfig {\n  /**\n   * Resolve the target live latency (seconds the playhead should trail the live\n   * edge) for the timeline-bearing track. Injected by the engine so the latency\n   * rule stays format-specific (HLS: `HOLD-BACK`, default 3× target duration;\n   * DASH would read `suggestedPresentationDelay`) while this behavior stays\n   * neutral. Absent → `0` (seek straight to the edge).\n   */\n  resolveLiveLatency?: ResolveLiveLatency;\n}\n\ntype SeekToLiveEdgeFsmState = 'inactive' | 'live';\n\n/**\n * `'live'` once the preconditions hold: a media element and a derivable live edge\n * (whose placement is final by construction — see the module docstring).\n * `'inactive'` otherwise.\n *\n * Deliberately narrow: every signal here can flip the reactor out of and back into\n * `live`, re-firing `entry`. Neither blinks mid-source — the edge can't, because\n * `liveWindowForType` falls back to any resolved track of the type — so `entry`\n * fires once per source without a latch, and a live reload (same source, slid\n * window) correctly doesn't re-command.\n *\n * The flip side: the presentation *url* is not part of this state, so replacing one\n * already-resolved live presentation with another would stay in `live` and never\n * command a start position for the new source. Unreachable today — every writer\n * sets `{ url }` (unresolved) or `undefined` first, so a source change always\n * transits `inactive`. Supporting a seeded pre-resolved presentation (via\n * `initialState`) that later changes would mean folding the url in here.\n */\nfunction deriveState(mediaElement: HTMLMediaElement | undefined, edge: LiveEdge | null): SeekToLiveEdgeFsmState {\n  return mediaElement && edge ? 'live' : 'inactive';\n}\n\nfunction seekToLiveEdgeSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<SeekToLiveEdgeState['presentation']>;\n    startPosition: Signal<SeekToLiveEdgeState['startPosition']>;\n    selectedVideoTrackId?: ReadonlySignal<SeekToLiveEdgeState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<SeekToLiveEdgeState['selectedAudioTrackId']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<SeekToLiveEdgeContext['mediaElement']>;\n  };\n  config?: SeekToLiveEdgeConfig;\n}): Reactor<SeekToLiveEdgeFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() => deriveState(context.mediaElement.get(), getLiveEdge({ state, config })));\n\n  return createMachineReactor<SeekToLiveEdgeFsmState>({\n    initial: 'inactive',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      inactive: {},\n\n      live: {\n        // One-time-per-source start position so the loader dispatches an in-window\n        // range and preload shows the right frame. The window-exit guard below is\n        // the separate, continuous rule. Live-specific — a future DVR mode skips\n        // even this first command (starts in place).\n        entry: () => {\n          // The monitor guarantees a media element + live edge while in `live`.\n          const mediaElement = context.mediaElement.get()!;\n          const { liveEdgeStart } = getLiveEdge({ state, config })!;\n          // Never command backwards: seeding `state.currentTime` behind a playhead\n          // already at/past the edge would drag the loaders back.\n          if (mediaElement.currentTime >= liveEdgeStart) return;\n          state.startPosition.set(liveEdgeStart);\n        },\n\n        // Window-exit guard. Repositions to the live edge when the playhead has\n        // fallen behind the window start, while playing. Two triggers: this\n        // effect's window-update re-fire (it reads the live edge, so each reload\n        // re-runs it — catches a stall, where `timeupdate` is silent) and a\n        // `play` listener for immediate reactivity on resume.\n        effects: () => {\n          // Read the live edge first — the only tracked dependency — so window\n          // slides keep re-firing this effect even while paused. Bailing before\n          // it (on paused) would drop the dependency and the effect would go\n          // inert, missing the next slide. The monitor guarantees the edge while\n          // in `live`; the media element is read untracked (the window update,\n          // not element identity, is the re-fire trigger).\n          const { start: windowStart, liveEdgeStart } = getLiveEdge({ state, config })!;\n          const mediaElement = peek(context.mediaElement)!;\n          const reposition = () => {\n            // Don't yank a paused viewer. We deliberately DON'T bail on\n            // `mediaElement.seeking`: a seek whose target sits behind the window\n            // start can never complete (the data has slid out of the window and\n            // been evicted), so `seeking` would stay true forever and strand the\n            // playhead — the very stall this guard exists to rescue. The\n            // `currentTime < windowStart` test is itself the precise\n            // discriminator: an in-window DVR scrub-back lands at\n            // `currentTime >= windowStart` and never trips it, so only a stuck\n            // out-of-window seek is repositioned.\n            if (mediaElement.paused) return;\n            if (mediaElement.currentTime < windowStart - REPOSITION_TOLERANCE) {\n              mediaElement.currentTime = liveEdgeStart;\n            }\n          };\n          reposition();\n          // `play` (not `playing`): a slid-past playhead is at an unseekable\n          // position where `playing` would stall and never fire; `play` fires on\n          // unpause regardless, so we snap before the stall.\n          return listen(mediaElement, 'play', reposition);\n        },\n      },\n    },\n  });\n}\n\n/**\n * Manual `Behavior<>` literal (like `calculatePresentationDuration`): declares\n * only `presentation` + `startPosition` in stateKeys while reading\n * `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the\n * switch* behaviors), so it composes without a stateKeys/type conflict.\n */\nexport const seekToLiveEdge: Behavior<\n  {\n    presentation: ReadonlySignal<SeekToLiveEdgeState['presentation']>;\n    startPosition: Signal<SeekToLiveEdgeState['startPosition']>;\n  },\n  { mediaElement: ReadonlySignal<SeekToLiveEdgeContext['mediaElement']> },\n  SeekToLiveEdgeConfig\n> = {\n  stateKeys: ['presentation', 'startPosition'],\n  contextKeys: ['mediaElement'],\n  setup: seekToLiveEdgeSetup,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;AAgD7B,SAAS,YAAY,cAA4C,MAA+C;CAC9G,OAAO,gBAAgB,OAAO,SAAS;AACzC;AAEA,SAAS,oBAAoB,EAC3B,OACA,SACA,UAY+D;CAC/D,MAAM,qBAAqB,eAAe,YAAY,QAAQ,aAAa,IAAI,GAAG,YAAY;EAAE;EAAO;CAAO,CAAC,CAAC,CAAC;CAEjH,OAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,UAAU,CAAC;GAEX,MAAM;IAKJ,aAAa;KAEX,MAAM,eAAe,QAAQ,aAAa,IAAI;KAC9C,MAAM,EAAE,kBAAkB,YAAY;MAAE;MAAO;KAAO,CAAC;KAGvD,IAAI,aAAa,eAAe,eAAe;KAC/C,MAAM,cAAc,IAAI,aAAa;IACvC;IAOA,eAAe;KAOb,MAAM,EAAE,OAAO,aAAa,kBAAkB,YAAY;MAAE;MAAO;KAAO,CAAC;KAC3E,MAAM,eAAe,KAAK,QAAQ,YAAY;KAC9C,MAAM,mBAAmB;MAUvB,IAAI,aAAa,QAAQ;MACzB,IAAI,aAAa,cAAc,cAAc,sBAC3C,aAAa,cAAc;KAE/B;KACA,WAAW;KAIX,OAAO,OAAO,cAAc,QAAQ,UAAU;IAChD;GACF;EACF;CACF,CAAC;AACH;;;;;;;AAQA,MAAa,iBAOT;CACF,WAAW,CAAC,gBAAgB,eAAe;CAC3C,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT"}
+{"version":3,"file":"seek-to-live-edge.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/seek-to-live-edge.ts"],"sourcesContent":["/**\n * Keep the playhead in the live window, via a two-state reactor gated on the preconditions for \"we know where live is\":\n *\n * - **`inactive`** — no media element, or no live edge (`getLiveEdge` is `null`: VOD, ended, or unresolved). Idle.\n * - **`live`** — preconditions met. `entry` commands `state.startPosition` once to the target live latency behind the\n *   edge (clamped to the window start) so playback begins near the edge and the loader dispatches an in-window range;\n *   `effects` runs the window-exit guard.\n *\n * A derivable live edge is itself the establishment gate: segment placement is settled at parse time — the reference\n * track's local placement _is_ the presentation timeline, and every other track's first parse is held until the anchor\n * is stamped (`resolve-track`'s gate + `establishStartMediaTime`) — so any window derived from resolved segments is\n * already final, with no separate anchor signal to wait on (see\n * `internal/design/spf/live-presentation-timeline-model.md`).\n *\n * The two pieces split along the axis a future DVR / EVENT mode will care about: the **one-time start position**\n * (`entry`) is the _live-specific_ behavior — start near the edge on load; a DVR mode makes it conditional (start in\n * place). The **window-exit guard** (`effects`) is the _general windowed-live_ behavior — applies to sliding-window\n * live, DVR, and EVENT alike. Because the command is an `entry`, it fires once per entry into `live`; a source change\n * exits to `inactive`, so the next source re-commands (no closure latch to reset). The guard stays a direct seek — it\n * is recurring, while `startPosition` is a self-clearing one-shot.\n *\n * Window-exit guard: while playing (not paused), reposition to the live edge when the playhead has fallen behind the\n * window start — including when a seek to a now-evicted position has stranded the playhead (such a seek can never\n * settle, so we rescue rather than wait on it). Two triggers: the **window-update re-fire** (the guard reads the live\n * edge, so each reload / slide re-runs it — this catches a stall, where `timeupdate` stops but the playlist keeps\n * reloading) and a **`play` listener** for immediate reactivity on resume, since the reload interval can be seconds.\n * `play`, not `playing`: after a long pause the playhead sits behind the window at an unseekable position, where the\n * browser stalls and `playing` never fires; `play` fires on the paused→false transition regardless, so we snap before\n * the stall. In-window pause / DVR scrub-back are left untouched.\n *\n * The latency comes from the injected `resolveLiveLatency` seam (HLS: `HOLD-BACK`), so this behavior carries no\n * delivery-format specifics. `applyStartPosition` performs the seek, gated on `loadedmetadata` — which implies an open\n * MediaSource and hence a declared seekable range (a seek outside `seekable` is clamped) — so this behavior needs no\n * MediaSource precondition of its own.\n */\nimport { listen } from '@videojs/utils/dom';\n\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor, type Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { getLiveEdge, type LiveEdge, type ResolveLiveLatency } from '../../primitives/live-window';\n\n/**\n * Tolerance (seconds) around the window edges before the guard repositions, so boundary / floating-point noise doesn't\n * trigger a spurious seek.\n */\nconst REPOSITION_TOLERANCE = 0.1;\n\nexport interface SeekToLiveEdgeState {\n  presentation?: MaybeResolvedPresentation;\n  /**\n   * One-shot start-position command in presentation-timeline seconds. Written here on entry into `live`; consumed\n   * (cleared) by `applyStartPosition`.\n   */\n  startPosition?: number;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\nexport interface SeekToLiveEdgeContext {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\nexport interface SeekToLiveEdgeConfig {\n  /**\n   * Resolve the target live latency (seconds the playhead should trail the live edge) for the timeline-bearing track.\n   * Injected by the engine so the latency rule stays format-specific (HLS: `HOLD-BACK`, default 3× target duration;\n   * DASH would read `suggestedPresentationDelay`) while this behavior stays neutral. Absent → `0` (seek straight to the\n   * edge).\n   */\n  resolveLiveLatency?: ResolveLiveLatency;\n}\n\ntype SeekToLiveEdgeFsmState = 'inactive' | 'live';\n\n/**\n * `'live'` once the preconditions hold: a media element and a derivable live edge (whose placement is final by\n * construction — see the module docstring). `'inactive'` otherwise.\n *\n * Deliberately narrow: every signal here can flip the reactor out of and back into `live`, re-firing `entry`. Neither\n * blinks mid-source — the edge can't, because `liveWindowForType` falls back to any resolved track of the type — so\n * `entry` fires once per source without a latch, and a live reload (same source, slid window) correctly doesn't\n * re-command.\n *\n * The flip side: the presentation _url_ is not part of this state, so replacing one already-resolved live presentation\n * with another would stay in `live` and never command a start position for the new source. Unreachable today — every\n * writer sets `{ url }` (unresolved) or `undefined` first, so a source change always transits `inactive`. Supporting a\n * seeded pre-resolved presentation (via `initialState`) that later changes would mean folding the url in here.\n */\nfunction deriveState(mediaElement: HTMLMediaElement | undefined, edge: LiveEdge | null): SeekToLiveEdgeFsmState {\n  return mediaElement && edge ? 'live' : 'inactive';\n}\n\nfunction seekToLiveEdgeSetup({\n  state,\n  context,\n  config,\n}: {\n  state: {\n    presentation: ReadonlySignal<SeekToLiveEdgeState['presentation']>;\n    startPosition: Signal<SeekToLiveEdgeState['startPosition']>;\n    selectedVideoTrackId?: ReadonlySignal<SeekToLiveEdgeState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<SeekToLiveEdgeState['selectedAudioTrackId']>;\n  };\n  context: {\n    mediaElement: ReadonlySignal<SeekToLiveEdgeContext['mediaElement']>;\n  };\n  config?: SeekToLiveEdgeConfig;\n}): Reactor<SeekToLiveEdgeFsmState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() => deriveState(context.mediaElement.get(), getLiveEdge({ state, config })));\n\n  return createMachineReactor<SeekToLiveEdgeFsmState>({\n    initial: 'inactive',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      inactive: {},\n\n      live: {\n        // One-time-per-source start position so the loader dispatches an in-window\n        // range and preload shows the right frame. The window-exit guard below is\n        // the separate, continuous rule. Live-specific — a future DVR mode skips\n        // even this first command (starts in place).\n        entry: () => {\n          // The monitor guarantees a media element + live edge while in `live`.\n          const mediaElement = context.mediaElement.get()!;\n          const { liveEdgeStart } = getLiveEdge({ state, config })!;\n          // Never command backwards: seeding `state.currentTime` behind a playhead\n          // already at/past the edge would drag the loaders back.\n          if (mediaElement.currentTime >= liveEdgeStart) return;\n\n          state.startPosition.set(liveEdgeStart);\n        },\n\n        // Window-exit guard. Repositions to the live edge when the playhead has\n        // fallen behind the window start, while playing. Two triggers: this\n        // effect's window-update re-fire (it reads the live edge, so each reload\n        // re-runs it — catches a stall, where `timeupdate` is silent) and a\n        // `play` listener for immediate reactivity on resume.\n        effects: () => {\n          // Read the live edge first — the only tracked dependency — so window\n          // slides keep re-firing this effect even while paused. Bailing before\n          // it (on paused) would drop the dependency and the effect would go\n          // inert, missing the next slide. The monitor guarantees the edge while\n          // in `live`; the media element is read untracked (the window update,\n          // not element identity, is the re-fire trigger).\n          const { start: windowStart, liveEdgeStart } = getLiveEdge({ state, config })!;\n          const mediaElement = peek(context.mediaElement)!;\n          const reposition = () => {\n            // Don't yank a paused viewer. We deliberately DON'T bail on\n            // `mediaElement.seeking`: a seek whose target sits behind the window\n            // start can never complete (the data has slid out of the window and\n            // been evicted), so `seeking` would stay true forever and strand the\n            // playhead — the very stall this guard exists to rescue. The\n            // `currentTime < windowStart` test is itself the precise\n            // discriminator: an in-window DVR scrub-back lands at\n            // `currentTime >= windowStart` and never trips it, so only a stuck\n            // out-of-window seek is repositioned.\n            if (mediaElement.paused) return;\n\n            if (mediaElement.currentTime < windowStart - REPOSITION_TOLERANCE) {\n              mediaElement.currentTime = liveEdgeStart;\n            }\n          };\n\n          reposition();\n          // `play` (not `playing`): a slid-past playhead is at an unseekable\n          // position where `playing` would stall and never fire; `play` fires on\n          // unpause regardless, so we snap before the stall.\n          return listen(mediaElement, 'play', reposition);\n        },\n      },\n    },\n  });\n}\n\n/**\n * Manual `Behavior<>` literal (like `calculatePresentationDuration`): declares only `presentation` + `startPosition` in\n * stateKeys while reading `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the switch*\n * behaviors), so it composes without a stateKeys/type conflict.\n */\nexport const seekToLiveEdge: Behavior<\n  {\n    presentation: ReadonlySignal<SeekToLiveEdgeState['presentation']>;\n    startPosition: Signal<SeekToLiveEdgeState['startPosition']>;\n  },\n  { mediaElement: ReadonlySignal<SeekToLiveEdgeContext['mediaElement']> },\n  SeekToLiveEdgeConfig\n> = {\n  stateKeys: ['presentation', 'startPosition'],\n  contextKeys: ['mediaElement'],\n  setup: seekToLiveEdgeSetup,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,MAAM,uBAAuB;;;;;;;;;;;;;;;AA2C7B,SAAS,YAAY,cAA4C,MAA+C;CAC9G,OAAO,gBAAgB,OAAO,SAAS;AACzC;AAEA,SAAS,oBAAoB,EAC3B,OACA,SACA,UAY+D;CAC/D,MAAM,qBAAqB,eAAe,YAAY,QAAQ,aAAa,IAAI,GAAG,YAAY;EAAE;EAAO;CAAO,CAAC,CAAC,CAAC;CAEjH,OAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,UAAU,CAAC;GAEX,MAAM;IAKJ,aAAa;KAEX,MAAM,eAAe,QAAQ,aAAa,IAAI;KAC9C,MAAM,EAAE,kBAAkB,YAAY;MAAE;MAAO;KAAO,CAAC;KAGvD,IAAI,aAAa,eAAe,eAAe;KAE/C,MAAM,cAAc,IAAI,aAAa;IACvC;IAOA,eAAe;KAOb,MAAM,EAAE,OAAO,aAAa,kBAAkB,YAAY;MAAE;MAAO;KAAO,CAAC;KAC3E,MAAM,eAAe,KAAK,QAAQ,YAAY;KAC9C,MAAM,mBAAmB;MAUvB,IAAI,aAAa,QAAQ;MAEzB,IAAI,aAAa,cAAc,cAAc,sBAC3C,aAAa,cAAc;KAE/B;KAEA,WAAW;KAIX,OAAO,OAAO,cAAc,QAAQ,UAAU;IAChD;GACF;EACF;CACF,CAAC;AACH;;;;;;AAOA,MAAa,iBAOT;CACF,WAAW,CAAC,gBAAgB,eAAe;CAC3C,aAAa,CAAC,cAAc;CAC5B,OAAO;AACT"}

package/dist/dev/playback/behaviors/dom/setup-buffer-actors.js

@@ -12,74 +12,55 @@ import { failoverFetch } from "../../primitives/failover-fetch.js";
 import { listen } from "@videojs/utils/dom";
 //#region src/playback/behaviors/dom/setup-buffer-actors.ts
 /**
-* **Per-type buffer + segment-loader actor setup.** Per available track
-* type (video / audio), when `mediaSource` is attached and the selected
-* track of that type is present in the presentation with codecs (partial
-* resolution from the multivariant playlist is enough — codecs live on
-* the `EXT-X-STREAM-INF` line, not in the per-type media playlist),
-* creates a `SourceBuffer`, a `SourceBufferActor`, and a
-* `SegmentLoaderActor` bound to that buffer-actor; publishes the per-type
-* actor slots. On `mediaSource` detach or behavior destroy, destroys both
-* actors in reverse order and clears the per-type slots so the next
-* source starts fresh.
+* **Per-type buffer + segment-loader actor setup.** Per available track type (video / audio), when `mediaSource` is
+* attached and the selected track of that type is present in the presentation with codecs (partial resolution from the
+* multivariant playlist is enough — codecs live on the `EXT-X-STREAM-INF` line, not in the per-type media playlist),
+* creates a `SourceBuffer`, a `SourceBufferActor`, and a `SegmentLoaderActor` bound to that buffer-actor; publishes the
+* per-type actor slots. On `mediaSource` detach or behavior destroy, destroys both actors in reverse order and clears
+* the per-type slots so the next source starts fresh.
 *
-* Each per-type variant (`setupVideoBufferActors` /
-* `setupAudioBufferActors`) is a single-positive-state reactor
-* (`'preconditions-unmet'` ↔ `'buffer-ready'`) gating only on its own
-* type. No cross-type coupling in `stateKeys` —
-* `setupVideoBufferActors` carries only `selectedVideoTrackId` (plus
-* `bandwidthState`, written by its trackedFetch), and audio mirrors.
+* Each per-type variant (`setupVideoBufferActors` / `setupAudioBufferActors`) is a single-positive-state reactor
+* (`'preconditions-unmet'` ↔ `'buffer-ready'`) gating only on its own type. No cross-type coupling in `stateKeys` —
+* `setupVideoBufferActors` carries only `selectedVideoTrackId` (plus `bandwidthState`, written by its trackedFetch),
+* and audio mirrors.
 *
 * # Firefox `mozHasAudio` invariant
 *
-* Appending to a video `SourceBuffer` before the audio `SourceBuffer`
-* exists causes `mozHasAudio` to be permanently false in Firefox. With
-* the two per-type variants decoupled, the invariant is no longer
-* structural to a single `entry` body (as it was when both buffers were
-* created in one synchronous block inside a merged behavior). It's now
-* preserved by a chain of assumptions about how this behavior composes
-* with its upstream and downstream siblings:
+* Appending to a video `SourceBuffer` before the audio `SourceBuffer` exists causes `mozHasAudio` to be permanently
+* false in Firefox. With the two per-type variants decoupled, the invariant is no longer structural to a single `entry`
+* body (as it was when both buffers were created in one synchronous block inside a merged behavior). It's now preserved
+* by a chain of assumptions about how this behavior composes with its upstream and downstream siblings:
 *
-* 1. **Upstream — default selections land in one `runPending`.**
-*    `selectAudioTrack` (default audio) and `switchVideoTrack`
-*    (default video) both subscribe to `state.presentation` flipping to
-*    resolved; their effects run in the same `runPending` iteration and
-*    write `selectedAudioTrackId` + `selectedVideoTrackId` within it.
-* 2. **Self — both per-type monitors flip in one `runPending`.**
-*    After (1), both monitors re-evaluate and flip to `'buffer-ready'`
-*    in the next `runPending`. Both `entry` bodies run synchronously
-*    within that iteration — both `addSourceBuffer` calls land before
-*    the iteration ends.
-* 3. **Downstream — `appendBuffer` is async.** `loadVideoSegments` /
-*    `loadAudioSegments` read the per-type `xSegmentLoaderActor` slots;
-*    their effects fire in the *next* `runPending` and the actual
-*    `appendBuffer` requires a network round-trip via the
-*    `SegmentLoaderActor` — many microtasks past both `addSourceBuffer`
-*    calls.
+* 1. **Upstream — default selections land in one `runPending`.** `selectAudioTrack` (default audio) and `switchVideoTrack`
+*    (default video) both subscribe to `state.presentation` flipping to resolved; their effects run in the same
+*    `runPending` iteration and write `selectedAudioTrackId` + `selectedVideoTrackId` within it.
+* 2. **Self — both per-type monitors flip in one `runPending`.** After (1), both monitors re-evaluate and flip to
+*    `'buffer-ready'` in the next `runPending`. Both `entry` bodies run synchronously within that iteration — both
+*    `addSourceBuffer` calls land before the iteration ends.
+* 3. **Downstream — `appendBuffer` is async.** `loadVideoSegments` / `loadAudioSegments` read the per-type
+*    `xSegmentLoaderActor` slots; their effects fire in the _next_ `runPending` and the actual `appendBuffer` requires
+*    a network round-trip via the `SegmentLoaderActor` — many microtasks past both `addSourceBuffer` calls.
 *
-* The cross-tick failure mode — a user-initiated audio track switch
-* *after* video segments have begun appending — is out of scope for
-* this behavior and would be addressed in the buffer/segment-loading
-* path via `changeType`-aware logic.
+* The cross-tick failure mode — a user-initiated audio track switch _after_ video segments have begun appending — is
+* out of scope for this behavior and would be addressed in the buffer/segment-loading path via `changeType`-aware
+* logic.
 *
 * # Sole writer
 *
-* `setupVideoBufferActors` is sole writer of `videoBufferActor` +
-* `videoSegmentLoaderActor` (and `bandwidthState` via its
-* trackedFetch); `setupAudioBufferActors` is sole writer of
-* `audioBufferActor` + `audioSegmentLoaderActor`. Both read
-* `mediaSource` from `setupMediaSource`. Downstream MSE behaviors
-* (`loadVideoSegments`, `loadAudioSegments`, `endOfStream`,
-* `updateMediaSourceDuration`) only read these slots.
+* `setupVideoBufferActors` is sole writer of `videoBufferActor` + `videoSegmentLoaderActor` (and `bandwidthState` via
+* its trackedFetch); `setupAudioBufferActors` is sole writer of `audioBufferActor` + `audioSegmentLoaderActor`. Both
+* read `mediaSource` from `setupMediaSource`. Downstream MSE behaviors (`loadVideoSegments`, `loadAudioSegments`,
+* `endOfStream`, `updateMediaSourceDuration`) only read these slots.
 */
 function setupBufferActors({ state, context, config }) {
 	const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer, messagePipelines } = config;
 	const derivedStateSignal = computed(() => {
 		if (!context.mediaSource.get()) return "preconditions-unmet";
-		return hasCodecs(getSelectedTrack({
+		const selection = {
 			presentation: state.presentation.get(),
 			[selectedKey]: state[selectedKey].get()
-		}, type)) ? "buffer-ready" : "preconditions-unmet";
+		};
+		return hasCodecs(getSelectedTrack(selection, type)) ? "buffer-ready" : "preconditions-unmet";
 	});
 	return createMachineReactor({
 		initial: "preconditions-unmet",
@@ -88,10 +69,13 @@ function setupBufferActors({ state, context, config }) {
 			"preconditions-unmet": {},
 			"buffer-ready": { entry: () => {
 				const mediaSource = context.mediaSource.get();
-				const bufferActor = createSourceBufferActor(createSourceBuffer(mediaSource, buildMimeCodec(getSelectedTrack({
+				const selection = {
 					presentation: state.presentation.get(),
 					[selectedKey]: state[selectedKey].get()
-				}, type))));
+				};
+				const track = getSelectedTrack(selection, type);
+				const buffer = createSourceBuffer(mediaSource, buildMimeCodec(track));
+				const bufferActor = createSourceBufferActor(buffer);
 				const segmentLoader = createSegmentLoaderActor(bufferActor, fetch, {
 					forwardBuffer,
 					backBuffer,
@@ -118,11 +102,9 @@ function setupBufferActors({ state, context, config }) {
 	});
 }
 /**
-* Set up the video `SourceBufferActor` + `SegmentLoaderActor`. Fires
-* when `mediaSource` is attached and the selected video track is
-* present in the presentation with codecs. Gates only on video state —
-* no cross-type coupling. Owns a bandwidth-sampling `trackedFetch` and
-* is sole writer of `state.bandwidthState`.
+* Set up the video `SourceBufferActor` + `SegmentLoaderActor`. Fires when `mediaSource` is attached and the selected
+* video track is present in the presentation with codecs. Gates only on video state — no cross-type coupling. Owns a
+* bandwidth-sampling `trackedFetch` and is sole writer of `state.bandwidthState`.
 */
 const setupVideoBufferActors = defineBehavior({
 	stateKeys: [
@@ -159,22 +141,16 @@ const setupVideoBufferActors = defineBehavior({
 	}
 });
 /**
-* Set up the audio `SourceBufferActor` + `SegmentLoaderActor`. Same
-* shape as `setupVideoBufferActors`, narrowed to audio. Today supplies
-* a non-sampling `fetchStream` (no audio ABR); adding audio ABR is a
-* localized change to this setup body (swap `fetchStream` for a
-* `createTrackedFetch` call + declare `bandwidthState` writable here)
-* without touching the shared helper. See
-* `internal/design/spf/features/audio-abr.md` for the design surface
-* (bandwidth-state sharing, multi-writer coordination, EWMA mixed-
-* source sampling).
+* Set up the audio `SourceBufferActor` + `SegmentLoaderActor`. Same shape as `setupVideoBufferActors`, narrowed to
+* audio. Today supplies a non-sampling `fetchStream` (no audio ABR); adding audio ABR is a localized change to this
+* setup body (swap `fetchStream` for a `createTrackedFetch` call + declare `bandwidthState` writable here) without
+* touching the shared helper. See `internal/design/spf/features/audio-abr.md` for the design surface (bandwidth-state
+* sharing, multi-writer coordination, EWMA mixed- source sampling).
 *
-* **Mid-stream audio track switching is NOT this behavior's concern.**
-* Slot writes to `selectedAudioTrackId` (default selection, programmatic
-* filter-driven, future ABR) are owned by `switchAudioTrack` / future
-* `switchAudioQuality` in `track-switching.ts`. Flush orchestration on
-* track change is dispatched from there via `audioBufferActor.send(...)`
-* — keeping this setup behavior focused on per-source actor lifecycle.
+* **Mid-stream audio track switching is NOT this behavior's concern.** Slot writes to `selectedAudioTrackId` (default
+* selection, programmatic filter-driven, future ABR) are owned by `switchAudioTrack` / future `switchAudioQuality` in
+* `track-switching.ts`. Flush orchestration on track change is dispatched from there via `audioBufferActor.send(...)` —
+* keeping this setup behavior focused on per-source actor lifecycle.
 */
 const setupAudioBufferActors = defineBehavior({
 	stateKeys: ["presentation", "selectedAudioTrackId"],

package/dist/dev/playback/behaviors/dom/setup-buffer-actors.js.map

@@ -1 +1 @@
-{"version":3,"file":"setup-buffer-actors.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-buffer-actors.ts"],"sourcesContent":["/**\n * **Per-type buffer + segment-loader actor setup.** Per available track\n * type (video / audio), when `mediaSource` is attached and the selected\n * track of that type is present in the presentation with codecs (partial\n * resolution from the multivariant playlist is enough — codecs live on\n * the `EXT-X-STREAM-INF` line, not in the per-type media playlist),\n * creates a `SourceBuffer`, a `SourceBufferActor`, and a\n * `SegmentLoaderActor` bound to that buffer-actor; publishes the per-type\n * actor slots. On `mediaSource` detach or behavior destroy, destroys both\n * actors in reverse order and clears the per-type slots so the next\n * source starts fresh.\n *\n * Each per-type variant (`setupVideoBufferActors` /\n * `setupAudioBufferActors`) is a single-positive-state reactor\n * (`'preconditions-unmet'` ↔ `'buffer-ready'`) gating only on its own\n * type. No cross-type coupling in `stateKeys` —\n * `setupVideoBufferActors` carries only `selectedVideoTrackId` (plus\n * `bandwidthState`, written by its trackedFetch), and audio mirrors.\n *\n * # Firefox `mozHasAudio` invariant\n *\n * Appending to a video `SourceBuffer` before the audio `SourceBuffer`\n * exists causes `mozHasAudio` to be permanently false in Firefox. With\n * the two per-type variants decoupled, the invariant is no longer\n * structural to a single `entry` body (as it was when both buffers were\n * created in one synchronous block inside a merged behavior). It's now\n * preserved by a chain of assumptions about how this behavior composes\n * with its upstream and downstream siblings:\n *\n * 1. **Upstream — default selections land in one `runPending`.**\n *    `selectAudioTrack` (default audio) and `switchVideoTrack`\n *    (default video) both subscribe to `state.presentation` flipping to\n *    resolved; their effects run in the same `runPending` iteration and\n *    write `selectedAudioTrackId` + `selectedVideoTrackId` within it.\n * 2. **Self — both per-type monitors flip in one `runPending`.**\n *    After (1), both monitors re-evaluate and flip to `'buffer-ready'`\n *    in the next `runPending`. Both `entry` bodies run synchronously\n *    within that iteration — both `addSourceBuffer` calls land before\n *    the iteration ends.\n * 3. **Downstream — `appendBuffer` is async.** `loadVideoSegments` /\n *    `loadAudioSegments` read the per-type `xSegmentLoaderActor` slots;\n *    their effects fire in the *next* `runPending` and the actual\n *    `appendBuffer` requires a network round-trip via the\n *    `SegmentLoaderActor` — many microtasks past both `addSourceBuffer`\n *    calls.\n *\n * The cross-tick failure mode — a user-initiated audio track switch\n * *after* video segments have begun appending — is out of scope for\n * this behavior and would be addressed in the buffer/segment-loading\n * path via `changeType`-aware logic.\n *\n * # Sole writer\n *\n * `setupVideoBufferActors` is sole writer of `videoBufferActor` +\n * `videoSegmentLoaderActor` (and `bandwidthState` via its\n * trackedFetch); `setupAudioBufferActors` is sole writer of\n * `audioBufferActor` + `audioSegmentLoaderActor`. Both read\n * `mediaSource` from `setupMediaSource`. Downstream MSE behaviors\n * (`loadVideoSegments`, `loadAudioSegments`, `endOfStream`,\n * `updateMediaSourceDuration`) only read these slots.\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, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { buildMimeCodec, createSourceBuffer } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTrack } from '../../../media/types';\nimport type { GetCdnId } from '../../../media/utils/cdn';\nimport { getSelectedTrack, type TrackSelectionState } from '../../../media/utils/track-selection';\nimport { hasCodecs } from '../../../media/utils/tracks';\nimport type { BandwidthState } from '../../../network/bandwidth-estimator';\nimport { createTrackedFetch, type FetchBytes, fetchStream } from '../../../network/fetch';\nimport {\n  createSegmentLoaderActor,\n  type SegmentLoaderActor,\n  type SegmentLoaderActorConfig,\n} from '../../actors/dom/segment-loader';\nimport { createSourceBufferActor, type SourceBufferActor } from '../../actors/dom/source-buffer';\nimport { failoverFetch } from '../../primitives/failover-fetch';\nimport type { MessagePipelines } from '../../primitives/segment-load-pipeline';\nimport { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../../primitives/track-types';\n\n/**\n * Media track type for MSE buffer setup.\n * Text tracks are excluded as they don't use MSE SourceBuffers.\n */\nexport type MediaTrackType = 'video' | 'audio';\n\nexport interface BufferActorsState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  bandwidthState?: BandwidthState;\n}\n\nexport interface BufferActorsContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n  videoSegmentLoaderActor?: SegmentLoaderActor;\n  audioSegmentLoaderActor?: SegmentLoaderActor;\n}\n\ntype BufferActorsFsmState = 'preconditions-unmet' | 'buffer-ready';\n\ntype SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId';\ntype BufferActorKey = 'videoBufferActor' | 'audioBufferActor';\ntype SegmentLoaderActorKey = 'videoSegmentLoaderActor' | 'audioSegmentLoaderActor';\n\ntype BufferActorsStateMap<K extends SelectedTrackKey> = {\n  presentation: ReadonlySignal<BufferActorsState['presentation']>;\n} & { [P in K]: ReadonlySignal<BufferActorsState[P]> };\n\ntype BufferActorsContextMap<A extends BufferActorKey, L extends SegmentLoaderActorKey> = {\n  mediaSource: ReadonlySignal<BufferActorsContext['mediaSource']>;\n} & { [P in A]: Signal<SourceBufferActor | undefined> } & {\n  [P in L]: Signal<SegmentLoaderActor | undefined>;\n};\n\n// ============================================================================\n// Specialization helper\n//\n// `setupBufferActors` has the same shape as a Behavior `setup` function:\n// `({ state, context, config }) => reactor`. Each `setupXBufferActors`\n// export below calls it from inside its own `defineBehavior` setup,\n// passing its narrowed `state` / `context` through directly and supplying\n// the per-type `selectedKey`, `actorKey`, `loaderKey`, `type` discriminator,\n// and `fetch` inline.\n//\n// Gating is per-type only: no cross-type coupling. See the file-level\n// JSDoc for how the Firefox `mozHasAudio` invariant survives the split\n// via SPF's effect coalescing.\n// ============================================================================\n\nfunction setupBufferActors<K extends SelectedTrackKey, A extends BufferActorKey, L extends SegmentLoaderActorKey>({\n  state,\n  context,\n  config,\n}: {\n  state: BufferActorsStateMap<K>;\n  context: BufferActorsContextMap<A, L>;\n  config: {\n    type: MediaTrackType;\n    selectedKey: K;\n    actorKey: A;\n    loaderKey: L;\n    fetch: FetchBytes;\n  } & SegmentLoaderActorConfig;\n}): Reactor<BufferActorsFsmState | 'destroying' | 'destroyed'> {\n  const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer, messagePipelines } = config;\n  const derivedStateSignal = computed<BufferActorsFsmState>(() => {\n    if (!context.mediaSource.get()) return 'preconditions-unmet';\n    const selection: TrackSelectionState = {\n      presentation: state.presentation.get(),\n      [selectedKey]: state[selectedKey].get(),\n    };\n    return hasCodecs(getSelectedTrack(selection, type)) ? 'buffer-ready' : 'preconditions-unmet';\n  });\n\n  return createMachineReactor<BufferActorsFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'buffer-ready': {\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const selection: TrackSelectionState = {\n            presentation: state.presentation.get(),\n            [selectedKey]: state[selectedKey].get(),\n          };\n          const track = getSelectedTrack(selection, type) as PartiallyResolvedTrack;\n          const buffer = createSourceBuffer(mediaSource, buildMimeCodec(track));\n          const bufferActor = createSourceBufferActor(buffer);\n          const segmentLoader = createSegmentLoaderActor(\n            bufferActor,\n            fetch,\n            { forwardBuffer, backBuffer, messagePipelines },\n            // Thread the composition deps opaquely to steps (relocation reads\n            // `state.mediaContainerData`); the loader/this behavior never read them.\n            { state, context, config }\n          );\n\n          // Synchronous slot writes — load-bearing for the Firefox\n          // `mozHasAudio` invariant (see file-level JSDoc). Both per-type\n          // entries' `addSourceBuffer` calls must land in the same\n          // `runPending` iteration; synchronous writes keep the contiguous\n          // JS frame. Downstream `loadXSegments` effects fire in the\n          // *next* `runPending`.\n          context[actorKey].set(bufferActor);\n          context[loaderKey].set(segmentLoader);\n\n          // State-exit cleanup — fires when `mediaSource` detaches, the\n          // selection unsets, or the behavior is destroyed. Destroy the\n          // loader before its upstream buffer-actor so any in-flight\n          // `appendBuffer` is aborted before the buffer-actor's own\n          // teardown. Idempotent, so the sourceclose listener below shares it.\n          const disconnect = new AbortController();\n          const teardownActors = () => {\n            segmentLoader.destroy();\n            bufferActor.destroy();\n            context[loaderKey].set(undefined);\n            context[actorKey].set(undefined);\n            disconnect.abort();\n          };\n\n          // Also tear down when the UA closes the MediaSource out from under\n          // us (notably an AirPlay handoff — see `setupAirPlay`). Must be a\n          // DOM listener, not reactive cleanup: already-queued append\n          // continuations outrun any effect flush, and only a synchronous\n          // abort keeps them off the dead SourceBuffer (InvalidStateError).\n          listen(mediaSource, 'sourceclose', teardownActors, { signal: disconnect.signal });\n\n          return teardownActors;\n        },\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Specialized exports — one per media type\n// ============================================================================\n\n/**\n * Set up the video `SourceBufferActor` + `SegmentLoaderActor`. Fires\n * when `mediaSource` is attached and the selected video track is\n * present in the presentation with codecs. Gates only on video state —\n * no cross-type coupling. Owns a bandwidth-sampling `trackedFetch` and\n * is sole writer of `state.bandwidthState`.\n */\nexport const setupVideoBufferActors = defineBehavior({\n  stateKeys: ['presentation', 'selectedVideoTrackId', 'bandwidthState'] as const,\n  contextKeys: ['mediaSource', 'videoBufferActor', 'videoSegmentLoaderActor'] as const,\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: BufferActorsStateMap<'selectedVideoTrackId'> & {\n      bandwidthState: Signal<BufferActorsState['bandwidthState']>;\n    };\n    context: BufferActorsContextMap<'videoBufferActor', 'videoSegmentLoaderActor'>;\n    config?: SegmentLoaderActorConfig & {\n      getCdnId?: GetCdnId;\n      /** Optional non-zero-PTS relocation pipelines (Tier-1); the loader uses its Tier-0 default when absent. */\n      videoMessagePipelines?: MessagePipelines;\n    };\n  }) => {\n    // Bandwidth-sampling fetch. The factory accumulates EWMA state\n    // internally; the callback bridges samples to engine state for ABR.\n    // Created once at behavior setup time so the EWMA accumulates across\n    // source resets (each per-source loader-actor receives the same\n    // tracked fetch when reconstructed in `buffer-ready` entry).\n    const trackedFetch = createTrackedFetch(\n      state.bandwidthState.get() ?? {\n        fastEstimate: 0,\n        fastTotalWeight: 0,\n        slowEstimate: 0,\n        slowTotalWeight: 0,\n        bytesSampled: 0,\n      },\n      (next) => state.bandwidthState.set(next)\n    );\n    // Engine `config` layers over the per-type defaults; `failoverFetch` reads\n    // its `selectedKey` + `getCdnId` from the merged result.\n    const typeConfig = { ...VIDEO_TYPE_CONFIG, ...config };\n    return setupBufferActors({\n      state,\n      context,\n      config: {\n        ...typeConfig,\n        messagePipelines: config.videoMessagePipelines,\n        fetch: failoverFetch(trackedFetch, state, typeConfig),\n      },\n    });\n  },\n});\n\n/**\n * Set up the audio `SourceBufferActor` + `SegmentLoaderActor`. Same\n * shape as `setupVideoBufferActors`, narrowed to audio. Today supplies\n * a non-sampling `fetchStream` (no audio ABR); adding audio ABR is a\n * localized change to this setup body (swap `fetchStream` for a\n * `createTrackedFetch` call + declare `bandwidthState` writable here)\n * without touching the shared helper. See\n * `internal/design/spf/features/audio-abr.md` for the design surface\n * (bandwidth-state sharing, multi-writer coordination, EWMA mixed-\n * source sampling).\n *\n * **Mid-stream audio track switching is NOT this behavior's concern.**\n * Slot writes to `selectedAudioTrackId` (default selection, programmatic\n * filter-driven, future ABR) are owned by `switchAudioTrack` / future\n * `switchAudioQuality` in `track-switching.ts`. Flush orchestration on\n * track change is dispatched from there via `audioBufferActor.send(...)`\n * — keeping this setup behavior focused on per-source actor lifecycle.\n */\nexport const setupAudioBufferActors = defineBehavior({\n  stateKeys: ['presentation', 'selectedAudioTrackId'] as const,\n  contextKeys: ['mediaSource', 'audioBufferActor', 'audioSegmentLoaderActor'] as const,\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: BufferActorsStateMap<'selectedAudioTrackId'>;\n    context: BufferActorsContextMap<'audioBufferActor', 'audioSegmentLoaderActor'>;\n    config?: SegmentLoaderActorConfig & {\n      getCdnId?: GetCdnId;\n      /** Optional non-zero-PTS relocation pipelines (Tier-1); the loader uses its Tier-0 default when absent. */\n      audioMessagePipelines?: MessagePipelines;\n    };\n  }) => {\n    // Key order mirrors setupVideoBufferActors.\n    const typeConfig = { ...AUDIO_TYPE_CONFIG, ...config };\n    return setupBufferActors({\n      state,\n      context,\n      config: {\n        ...typeConfig,\n        messagePipelines: config.audioMessagePipelines,\n        fetch: failoverFetch(fetchStream, state, typeConfig),\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuIA,SAAS,kBAAyG,EAChH,OACA,SACA,UAW6D;CAC7D,MAAM,EAAE,MAAM,aAAa,UAAU,WAAW,OAAO,eAAe,YAAY,qBAAqB;CACvG,MAAM,qBAAqB,eAAqC;EAC9D,IAAI,CAAC,QAAQ,YAAY,IAAI,GAAG,OAAO;EAKvC,OAAO,UAAU,iBAAiB;GAHhC,cAAc,MAAM,aAAa,IAAI;IACpC,cAAc,MAAM,YAAY,CAAC,IAAI;EAEE,GAAG,IAAI,CAAC,IAAI,iBAAiB;CACzE,CAAC;CAED,OAAO,qBAA2C;EAChD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,gBAAgB,EACd,aAAa;IACX,MAAM,cAAc,QAAQ,YAAY,IAAI;IAO5C,MAAM,cAAc,wBADL,mBAAmB,aAAa,eADjC,iBAAiB;KAH7B,cAAc,MAAM,aAAa,IAAI;MACpC,cAAc,MAAM,YAAY,CAAC,IAAI;IAED,GAAG,IACwB,CAAC,CAClB,CAAC;IAClD,MAAM,gBAAgB,yBACpB,aACA,OACA;KAAE;KAAe;KAAY;IAAiB,GAG9C;KAAE;KAAO;KAAS;IAAO,CAC3B;IAQA,QAAQ,SAAS,CAAC,IAAI,WAAW;IACjC,QAAQ,UAAU,CAAC,IAAI,aAAa;IAOpC,MAAM,aAAa,IAAI,gBAAgB;IACvC,MAAM,uBAAuB;KAC3B,cAAc,QAAQ;KACtB,YAAY,QAAQ;KACpB,QAAQ,UAAU,CAAC,IAAI,KAAA,CAAS;KAChC,QAAQ,SAAS,CAAC,IAAI,KAAA,CAAS;KAC/B,WAAW,MAAM;IACnB;IAOA,OAAO,aAAa,eAAe,gBAAgB,EAAE,QAAQ,WAAW,OAAO,CAAC;IAEhF,OAAO;GACT,EACF;EACF;CACF,CAAC;AACH;;;;;;;;AAaA,MAAa,yBAAyB,eAAe;CACnD,WAAW;EAAC;EAAgB;EAAwB;CAAgB;CACpE,aAAa;EAAC;EAAe;EAAoB;CAAyB;CAC1E,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QAWN;EAMJ,MAAM,eAAe,mBACnB,MAAM,eAAe,IAAI,KAAK;GAC5B,cAAc;GACd,iBAAiB;GACjB,cAAc;GACd,iBAAiB;GACjB,cAAc;EAChB,IACC,SAAS,MAAM,eAAe,IAAI,IAAI,CACzC;EAGA,MAAM,aAAa;GAAE,GAAG;GAAmB,GAAG;EAAO;EACrD,OAAO,kBAAkB;GACvB;GACA;GACA,QAAQ;IACN,GAAG;IACH,kBAAkB,OAAO;IACzB,OAAO,cAAc,cAAc,OAAO,UAAU;GACtD;EACF,CAAC;CACH;AACF,CAAC;;;;;;;;;;;;;;;;;;;AAoBD,MAAa,yBAAyB,eAAe;CACnD,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa;EAAC;EAAe;EAAoB;CAAyB;CAC1E,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QASN;EAEJ,MAAM,aAAa;GAAE,GAAG;GAAmB,GAAG;EAAO;EACrD,OAAO,kBAAkB;GACvB;GACA;GACA,QAAQ;IACN,GAAG;IACH,kBAAkB,OAAO;IACzB,OAAO,cAAc,aAAa,OAAO,UAAU;GACrD;EACF,CAAC;CACH;AACF,CAAC"}
+{"version":3,"file":"setup-buffer-actors.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-buffer-actors.ts"],"sourcesContent":["/**\n * **Per-type buffer + segment-loader actor setup.** Per available track type (video / audio), when `mediaSource` is\n * attached and the selected track of that type is present in the presentation with codecs (partial resolution from the\n * multivariant playlist is enough — codecs live on the `EXT-X-STREAM-INF` line, not in the per-type media playlist),\n * creates a `SourceBuffer`, a `SourceBufferActor`, and a `SegmentLoaderActor` bound to that buffer-actor; publishes the\n * per-type actor slots. On `mediaSource` detach or behavior destroy, destroys both actors in reverse order and clears\n * the per-type slots so the next source starts fresh.\n *\n * Each per-type variant (`setupVideoBufferActors` / `setupAudioBufferActors`) is a single-positive-state reactor\n * (`'preconditions-unmet'` ↔ `'buffer-ready'`) gating only on its own type. No cross-type coupling in `stateKeys` —\n * `setupVideoBufferActors` carries only `selectedVideoTrackId` (plus `bandwidthState`, written by its trackedFetch),\n * and audio mirrors.\n *\n * # Firefox `mozHasAudio` invariant\n *\n * Appending to a video `SourceBuffer` before the audio `SourceBuffer` exists causes `mozHasAudio` to be permanently\n * false in Firefox. With the two per-type variants decoupled, the invariant is no longer structural to a single `entry`\n * body (as it was when both buffers were created in one synchronous block inside a merged behavior). It's now preserved\n * by a chain of assumptions about how this behavior composes with its upstream and downstream siblings:\n *\n * 1. **Upstream — default selections land in one `runPending`.** `selectAudioTrack` (default audio) and `switchVideoTrack`\n *    (default video) both subscribe to `state.presentation` flipping to resolved; their effects run in the same\n *    `runPending` iteration and write `selectedAudioTrackId` + `selectedVideoTrackId` within it.\n * 2. **Self — both per-type monitors flip in one `runPending`.** After (1), both monitors re-evaluate and flip to\n *    `'buffer-ready'` in the next `runPending`. Both `entry` bodies run synchronously within that iteration — both\n *    `addSourceBuffer` calls land before the iteration ends.\n * 3. **Downstream — `appendBuffer` is async.** `loadVideoSegments` / `loadAudioSegments` read the per-type\n *    `xSegmentLoaderActor` slots; their effects fire in the _next_ `runPending` and the actual `appendBuffer` requires\n *    a network round-trip via the `SegmentLoaderActor` — many microtasks past both `addSourceBuffer` calls.\n *\n * The cross-tick failure mode — a user-initiated audio track switch _after_ video segments have begun appending — is\n * out of scope for this behavior and would be addressed in the buffer/segment-loading path via `changeType`-aware\n * logic.\n *\n * # Sole writer\n *\n * `setupVideoBufferActors` is sole writer of `videoBufferActor` + `videoSegmentLoaderActor` (and `bandwidthState` via\n * its trackedFetch); `setupAudioBufferActors` is sole writer of `audioBufferActor` + `audioSegmentLoaderActor`. Both\n * read `mediaSource` from `setupMediaSource`. Downstream MSE behaviors (`loadVideoSegments`, `loadAudioSegments`,\n * `endOfStream`, `updateMediaSourceDuration`) only read these slots.\n */\nimport { listen } from '@videojs/utils/dom';\n\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, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { buildMimeCodec, createSourceBuffer } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTrack } from '../../../media/types';\nimport type { GetCdnId } from '../../../media/utils/cdn';\nimport { getSelectedTrack, type TrackSelectionState } from '../../../media/utils/track-selection';\nimport { hasCodecs } from '../../../media/utils/tracks';\nimport type { BandwidthState } from '../../../network/bandwidth-estimator';\nimport { createTrackedFetch, type FetchBytes, fetchStream } from '../../../network/fetch';\nimport {\n  createSegmentLoaderActor,\n  type SegmentLoaderActor,\n  type SegmentLoaderActorConfig,\n} from '../../actors/dom/segment-loader';\nimport { createSourceBufferActor, type SourceBufferActor } from '../../actors/dom/source-buffer';\nimport { failoverFetch } from '../../primitives/failover-fetch';\nimport type { MessagePipelines } from '../../primitives/segment-load-pipeline';\nimport { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../../primitives/track-types';\n\n/** Media track type for MSE buffer setup. Text tracks are excluded as they don't use MSE SourceBuffers. */\nexport type MediaTrackType = 'video' | 'audio';\n\nexport interface BufferActorsState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  bandwidthState?: BandwidthState;\n}\n\nexport interface BufferActorsContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n  videoSegmentLoaderActor?: SegmentLoaderActor;\n  audioSegmentLoaderActor?: SegmentLoaderActor;\n}\n\ntype BufferActorsFsmState = 'preconditions-unmet' | 'buffer-ready';\n\ntype SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId';\ntype BufferActorKey = 'videoBufferActor' | 'audioBufferActor';\ntype SegmentLoaderActorKey = 'videoSegmentLoaderActor' | 'audioSegmentLoaderActor';\n\ntype BufferActorsStateMap<K extends SelectedTrackKey> = {\n  presentation: ReadonlySignal<BufferActorsState['presentation']>;\n} & { [P in K]: ReadonlySignal<BufferActorsState[P]> };\n\ntype BufferActorsContextMap<A extends BufferActorKey, L extends SegmentLoaderActorKey> = {\n  mediaSource: ReadonlySignal<BufferActorsContext['mediaSource']>;\n} & { [P in A]: Signal<SourceBufferActor | undefined> } & {\n  [P in L]: Signal<SegmentLoaderActor | undefined>;\n};\n\n// ============================================================================\n// Specialization helper\n//\n// `setupBufferActors` has the same shape as a Behavior `setup` function:\n// `({ state, context, config }) => reactor`. Each `setupXBufferActors`\n// export below calls it from inside its own `defineBehavior` setup,\n// passing its narrowed `state` / `context` through directly and supplying\n// the per-type `selectedKey`, `actorKey`, `loaderKey`, `type` discriminator,\n// and `fetch` inline.\n//\n// Gating is per-type only: no cross-type coupling. See the file-level\n// JSDoc for how the Firefox `mozHasAudio` invariant survives the split\n// via SPF's effect coalescing.\n// ============================================================================\n\nfunction setupBufferActors<K extends SelectedTrackKey, A extends BufferActorKey, L extends SegmentLoaderActorKey>({\n  state,\n  context,\n  config,\n}: {\n  state: BufferActorsStateMap<K>;\n  context: BufferActorsContextMap<A, L>;\n  config: {\n    type: MediaTrackType;\n    selectedKey: K;\n    actorKey: A;\n    loaderKey: L;\n    fetch: FetchBytes;\n  } & SegmentLoaderActorConfig;\n}): Reactor<BufferActorsFsmState | 'destroying' | 'destroyed'> {\n  const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer, messagePipelines } = config;\n  const derivedStateSignal = computed<BufferActorsFsmState>(() => {\n    if (!context.mediaSource.get()) return 'preconditions-unmet';\n\n    const selection: TrackSelectionState = {\n      presentation: state.presentation.get(),\n      [selectedKey]: state[selectedKey].get(),\n    };\n\n    return hasCodecs(getSelectedTrack(selection, type)) ? 'buffer-ready' : 'preconditions-unmet';\n  });\n\n  return createMachineReactor<BufferActorsFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'buffer-ready': {\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const selection: TrackSelectionState = {\n            presentation: state.presentation.get(),\n            [selectedKey]: state[selectedKey].get(),\n          };\n          const track = getSelectedTrack(selection, type) as PartiallyResolvedTrack;\n          const buffer = createSourceBuffer(mediaSource, buildMimeCodec(track));\n          const bufferActor = createSourceBufferActor(buffer);\n          const segmentLoader = createSegmentLoaderActor(\n            bufferActor,\n            fetch,\n            { forwardBuffer, backBuffer, messagePipelines },\n            // Thread the composition deps opaquely to steps (relocation reads\n            // `state.mediaContainerData`); the loader/this behavior never read them.\n            { state, context, config }\n          );\n\n          // Synchronous slot writes — load-bearing for the Firefox\n          // `mozHasAudio` invariant (see file-level JSDoc). Both per-type\n          // entries' `addSourceBuffer` calls must land in the same\n          // `runPending` iteration; synchronous writes keep the contiguous\n          // JS frame. Downstream `loadXSegments` effects fire in the\n          // *next* `runPending`.\n          context[actorKey].set(bufferActor);\n          context[loaderKey].set(segmentLoader);\n\n          // State-exit cleanup — fires when `mediaSource` detaches, the\n          // selection unsets, or the behavior is destroyed. Destroy the\n          // loader before its upstream buffer-actor so any in-flight\n          // `appendBuffer` is aborted before the buffer-actor's own\n          // teardown. Idempotent, so the sourceclose listener below shares it.\n          const disconnect = new AbortController();\n          const teardownActors = () => {\n            segmentLoader.destroy();\n            bufferActor.destroy();\n            context[loaderKey].set(undefined);\n            context[actorKey].set(undefined);\n            disconnect.abort();\n          };\n\n          // Also tear down when the UA closes the MediaSource out from under\n          // us (notably an AirPlay handoff — see `setupAirPlay`). Must be a\n          // DOM listener, not reactive cleanup: already-queued append\n          // continuations outrun any effect flush, and only a synchronous\n          // abort keeps them off the dead SourceBuffer (InvalidStateError).\n          listen(mediaSource, 'sourceclose', teardownActors, { signal: disconnect.signal });\n\n          return teardownActors;\n        },\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Specialized exports — one per media type\n// ============================================================================\n\n/**\n * Set up the video `SourceBufferActor` + `SegmentLoaderActor`. Fires when `mediaSource` is attached and the selected\n * video track is present in the presentation with codecs. Gates only on video state — no cross-type coupling. Owns a\n * bandwidth-sampling `trackedFetch` and is sole writer of `state.bandwidthState`.\n */\nexport const setupVideoBufferActors = defineBehavior({\n  stateKeys: ['presentation', 'selectedVideoTrackId', 'bandwidthState'] as const,\n  contextKeys: ['mediaSource', 'videoBufferActor', 'videoSegmentLoaderActor'] as const,\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: BufferActorsStateMap<'selectedVideoTrackId'> & {\n      bandwidthState: Signal<BufferActorsState['bandwidthState']>;\n    };\n    context: BufferActorsContextMap<'videoBufferActor', 'videoSegmentLoaderActor'>;\n    config?: SegmentLoaderActorConfig & {\n      getCdnId?: GetCdnId;\n      /** Optional non-zero-PTS relocation pipelines (Tier-1); the loader uses its Tier-0 default when absent. */\n      videoMessagePipelines?: MessagePipelines;\n    };\n  }) => {\n    // Bandwidth-sampling fetch. The factory accumulates EWMA state\n    // internally; the callback bridges samples to engine state for ABR.\n    // Created once at behavior setup time so the EWMA accumulates across\n    // source resets (each per-source loader-actor receives the same\n    // tracked fetch when reconstructed in `buffer-ready` entry).\n    const trackedFetch = createTrackedFetch(\n      state.bandwidthState.get() ?? {\n        fastEstimate: 0,\n        fastTotalWeight: 0,\n        slowEstimate: 0,\n        slowTotalWeight: 0,\n        bytesSampled: 0,\n      },\n      (next) => state.bandwidthState.set(next)\n    );\n    // Engine `config` layers over the per-type defaults; `failoverFetch` reads\n    // its `selectedKey` + `getCdnId` from the merged result.\n    const typeConfig = { ...VIDEO_TYPE_CONFIG, ...config };\n\n    return setupBufferActors({\n      state,\n      context,\n      config: {\n        ...typeConfig,\n        messagePipelines: config.videoMessagePipelines,\n        fetch: failoverFetch(trackedFetch, state, typeConfig),\n      },\n    });\n  },\n});\n\n/**\n * Set up the audio `SourceBufferActor` + `SegmentLoaderActor`. Same shape as `setupVideoBufferActors`, narrowed to\n * audio. Today supplies a non-sampling `fetchStream` (no audio ABR); adding audio ABR is a localized change to this\n * setup body (swap `fetchStream` for a `createTrackedFetch` call + declare `bandwidthState` writable here) without\n * touching the shared helper. See `internal/design/spf/features/audio-abr.md` for the design surface (bandwidth-state\n * sharing, multi-writer coordination, EWMA mixed- source sampling).\n *\n * **Mid-stream audio track switching is NOT this behavior's concern.** Slot writes to `selectedAudioTrackId` (default\n * selection, programmatic filter-driven, future ABR) are owned by `switchAudioTrack` / future `switchAudioQuality` in\n * `track-switching.ts`. Flush orchestration on track change is dispatched from there via `audioBufferActor.send(...)` —\n * keeping this setup behavior focused on per-source actor lifecycle.\n */\nexport const setupAudioBufferActors = defineBehavior({\n  stateKeys: ['presentation', 'selectedAudioTrackId'] as const,\n  contextKeys: ['mediaSource', 'audioBufferActor', 'audioSegmentLoaderActor'] as const,\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: BufferActorsStateMap<'selectedAudioTrackId'>;\n    context: BufferActorsContextMap<'audioBufferActor', 'audioSegmentLoaderActor'>;\n    config?: SegmentLoaderActorConfig & {\n      getCdnId?: GetCdnId;\n      /** Optional non-zero-PTS relocation pipelines (Tier-1); the loader uses its Tier-0 default when absent. */\n      audioMessagePipelines?: MessagePipelines;\n    };\n  }) => {\n    // Key order mirrors setupVideoBufferActors.\n    const typeConfig = { ...AUDIO_TYPE_CONFIG, ...config };\n\n    return setupBufferActors({\n      state,\n      context,\n      config: {\n        ...typeConfig,\n        messagePipelines: config.audioMessagePipelines,\n        fetch: failoverFetch(fetchStream, state, typeConfig),\n      },\n    });\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiHA,SAAS,kBAAyG,EAChH,OACA,SACA,UAW6D;CAC7D,MAAM,EAAE,MAAM,aAAa,UAAU,WAAW,OAAO,eAAe,YAAY,qBAAqB;CACvG,MAAM,qBAAqB,eAAqC;EAC9D,IAAI,CAAC,QAAQ,YAAY,IAAI,GAAG,OAAO;EAEvC,MAAM,YAAiC;GACrC,cAAc,MAAM,aAAa,IAAI;IACpC,cAAc,MAAM,YAAY,CAAC,IAAI;EACxC;EAEA,OAAO,UAAU,iBAAiB,WAAW,IAAI,CAAC,IAAI,iBAAiB;CACzE,CAAC;CAED,OAAO,qBAA2C;EAChD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GAExB,gBAAgB,EACd,aAAa;IACX,MAAM,cAAc,QAAQ,YAAY,IAAI;IAC5C,MAAM,YAAiC;KACrC,cAAc,MAAM,aAAa,IAAI;MACpC,cAAc,MAAM,YAAY,CAAC,IAAI;IACxC;IACA,MAAM,QAAQ,iBAAiB,WAAW,IAAI;IAC9C,MAAM,SAAS,mBAAmB,aAAa,eAAe,KAAK,CAAC;IACpE,MAAM,cAAc,wBAAwB,MAAM;IAClD,MAAM,gBAAgB,yBACpB,aACA,OACA;KAAE;KAAe;KAAY;IAAiB,GAG9C;KAAE;KAAO;KAAS;IAAO,CAC3B;IAQA,QAAQ,SAAS,CAAC,IAAI,WAAW;IACjC,QAAQ,UAAU,CAAC,IAAI,aAAa;IAOpC,MAAM,aAAa,IAAI,gBAAgB;IACvC,MAAM,uBAAuB;KAC3B,cAAc,QAAQ;KACtB,YAAY,QAAQ;KACpB,QAAQ,UAAU,CAAC,IAAI,KAAA,CAAS;KAChC,QAAQ,SAAS,CAAC,IAAI,KAAA,CAAS;KAC/B,WAAW,MAAM;IACnB;IAOA,OAAO,aAAa,eAAe,gBAAgB,EAAE,QAAQ,WAAW,OAAO,CAAC;IAEhF,OAAO;GACT,EACF;EACF;CACF,CAAC;AACH;;;;;;AAWA,MAAa,yBAAyB,eAAe;CACnD,WAAW;EAAC;EAAgB;EAAwB;CAAgB;CACpE,aAAa;EAAC;EAAe;EAAoB;CAAyB;CAC1E,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QAWN;EAMJ,MAAM,eAAe,mBACnB,MAAM,eAAe,IAAI,KAAK;GAC5B,cAAc;GACd,iBAAiB;GACjB,cAAc;GACd,iBAAiB;GACjB,cAAc;EAChB,IACC,SAAS,MAAM,eAAe,IAAI,IAAI,CACzC;EAGA,MAAM,aAAa;GAAE,GAAG;GAAmB,GAAG;EAAO;EAErD,OAAO,kBAAkB;GACvB;GACA;GACA,QAAQ;IACN,GAAG;IACH,kBAAkB,OAAO;IACzB,OAAO,cAAc,cAAc,OAAO,UAAU;GACtD;EACF,CAAC;CACH;AACF,CAAC;;;;;;;;;;;;;AAcD,MAAa,yBAAyB,eAAe;CACnD,WAAW,CAAC,gBAAgB,sBAAsB;CAClD,aAAa;EAAC;EAAe;EAAoB;CAAyB;CAC1E,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QASN;EAEJ,MAAM,aAAa;GAAE,GAAG;GAAmB,GAAG;EAAO;EAErD,OAAO,kBAAkB;GACvB;GACA;GACA,QAAQ;IACN,GAAG;IACH,kBAAkB,OAAO;IACzB,OAAO,cAAc,aAAa,OAAO,UAAU;GACrD;EACF,CAAC;CACH;AACF,CAAC"}

package/dist/dev/playback/behaviors/dom/setup-mediasource.js

@@ -6,58 +6,44 @@ import { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from "..
 import { listen } from "@videojs/utils/dom";
 //#region src/playback/behaviors/dom/setup-mediasource.ts
 /**
-* **Own the MediaSource lifecycle for the current source.** When a resolved
-* presentation and a mediaElement are both in scope, creates a MediaSource,
-* attaches it to the element, waits for `'open'`, and publishes it on
-* `context.mediaSource`. On source change or behavior destroy, detaches the
-* MediaSource and clears the slot so the next source starts fresh.
+* **Own the MediaSource lifecycle for the current source.** When a resolved presentation and a mediaElement are both in
+* scope, creates a MediaSource, attaches it to the element, waits for `'open'`, and publishes it on
+* `context.mediaSource`. On source change or behavior destroy, detaches the MediaSource and clears the slot so the next
+* source starts fresh.
 *
-* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`):
-* state derivation gates on `mediaElement + isResolvedPresentation`. Riding the
-* resolver's resolved/unresolved lifecycle makes direct URL replacement
-* structural — `resolvePresentation` routes the presentation back through
-* unresolved on URL change, which drives this reactor through
-* `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old
-* MediaSource before the new one is built.
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`): state derivation gates on
+* `mediaElement + isResolvedPresentation`. Riding the resolver's resolved/unresolved lifecycle makes direct URL
+* replacement structural — `resolvePresentation` routes the presentation back through unresolved on URL change, which
+* drives this reactor through `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old MediaSource
+* before the new one is built.
 *
 * The entry resolves preconditions in sequence before publishing:
 *
-* 1. **Create + attach** — `createMediaSource` + `attachMediaSource` run
-*    synchronously on entry. The `detach` closure returned by
-*    `attachMediaSource` is captured for state-exit cleanup, so the cleanup
-*    is always bound to its setup even if the wait below is aborted.
-* 2. **Wait for `'open'`** — `waitForMediaSourceOpen` defers until the first
-*    `sourceopen` event (or any readyState transition out of `'closed'`).
-* 3. **Publish on `'open'`** — re-check `readyState === 'open'` after the
-*    await (covers `'ended'` / `'closed'` race) before writing to
-*    `context.mediaSource`. Downstream `setupVideoBufferActors` /
-*    `setupAudioBufferActors` call `addSourceBuffer` directly, which
-*    throws on non-open, so publish-only-when-open is the load-bearing
-*    contract.
+* 1. **Create + attach** — `createMediaSource` + `attachMediaSource` run synchronously on entry. The `detach` closure
+*    returned by `attachMediaSource` is captured for state-exit cleanup, so the cleanup is always bound to its setup
+*    even if the wait below is aborted.
+* 2. **Wait for `'open'`** — `waitForMediaSourceOpen` defers until the first `sourceopen` event (or any readyState
+*    transition out of `'closed'`).
+* 3. **Publish on `'open'`** — re-check `readyState === 'open'` after the await (covers `'ended'` / `'closed'` race)
+*    before writing to `context.mediaSource`. Downstream `setupVideoBufferActors` / `setupAudioBufferActors` call
+*    `addSourceBuffer` directly, which throws on non-open, so publish-only-when-open is the load-bearing contract.
 *
-* State-exit cleanup aborts the in-flight wait, detaches the MediaSource,
-* and clears `context.mediaSource`. Order: abort first (prevents a late
-* publish racing the slot clear), then detach, then clear.
+* State-exit cleanup aborts the in-flight wait, detaches the MediaSource, and clears `context.mediaSource`. Order:
+* abort first (prevents a late publish racing the slot clear), then detach, then clear.
 *
 * # Sourceclose recovery
 *
-* The behavior owns one **unclosed** MediaSource per source identity. The UA can
-* close the attached MediaSource out from under the engine (Safari on an
-* AirPlay handoff — see `setupAirPlay` — or a ManagedMediaSource evicted
-* under memory pressure), and a closed MediaSource can never reopen. The
-* `sourceclose` listener tears the attachment down synchronously; every
-* teardown records a local close-fact, which holds the machine out until
-* the fact is consumed — then the re-derive comes back in with a fresh
-* MediaSource for the *same* source. Cause-agnostic. Consumption honors an
-* observed `loadingSuspended` (attaching runs `element.load()` — new loading
-* work, e.g. resource selection under an active AirPlay receiver), and
-* happens only while the machine is out, so a suspension can never tear
-* down an existing attachment.
+* The behavior owns one **unclosed** MediaSource per source identity. The UA can close the attached MediaSource out
+* from under the engine (Safari on an AirPlay handoff — see `setupAirPlay` — or a ManagedMediaSource evicted under
+* memory pressure), and a closed MediaSource can never reopen. The `sourceclose` listener tears the attachment down
+* synchronously; every teardown records a local close-fact, which holds the machine out until the fact is consumed —
+* then the re-derive comes back in with a fresh MediaSource for the _same_ source. Cause-agnostic. Consumption honors
+* an observed `loadingSuspended` (attaching runs `element.load()` — new loading work, e.g. resource selection under an
+* active AirPlay receiver), and happens only while the machine is out, so a suspension can never tear down an existing
+* attachment.
 *
-* Sole writer of `context.mediaSource`; other MSE behaviors
-* (`setupVideoBufferActors`, `setupAudioBufferActors`,
-* `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only
-* read.
+* Sole writer of `context.mediaSource`; other MSE behaviors (`setupVideoBufferActors`, `setupAudioBufferActors`,
+* `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only read.
 */
 function deriveState(presentation, mediaElement, mediaSourceClosed) {
 	if (!mediaElement || !isResolvedPresentation(presentation)) return "preconditions-unmet";