npm - @videojs/spf - Versions diffs - 10.0.0-beta.24 → 10.0.0-beta.26 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (375) hide show

package/dist/default/playback/behaviors/dom/load-segments.js CHANGED Viewed

@@ -3,7 +3,7 @@ import { defineBehavior } from "../../../core/composition/create-composition.js"
 import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
 import { DEFAULT_FORWARD_BUFFER_CONFIG, segmentStartForTime } from "../../../media/buffer/forward-buffer.js";
 import { findResolvedAudioTrack, findResolvedTextTrack, findResolvedVideoTrack } from "../../../media/utils/tracks.js";
-import { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../track-types.js";
+import { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../../primitives/track-types.js";
 //#region src/playback/behaviors/dom/load-segments.ts
 /**
 * **Per-type segment loading dispatch.** Per available track type (video /
@@ -26,7 +26,10 @@ import { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../track
 *
 * - `'preconditions-unmet'` — no loader actor in context, or the selected
 *   track hasn't resolved.
-* - `'dormant'` — `preload === 'none' && !loadActivated`. Nothing fires.
+* - `'dormant'` — loading disabled by policy: an observed `loadingSuspended`
+*   (highest precedence) or `preload === 'none' && !loadActivated`. Nothing
+*   fires; already-queued loader work drains. Auto-resumes into the derived
+*   state when the policy lifts.
 * - `'metadata-only'` — `!loadActivated && preload !== 'auto' && preload !== 'none'`.
 *   Fires an init-segment-only `load` message **once on entry**. The
 *   variant's loader actor decides what to do — v/a's actor fetches the
@@ -71,6 +74,7 @@ function setupSegmentLoading({ state, context, config }) {
 		return segmentStartForTime(state.currentTime.get() ?? 0, track.segments);
 	});
 	const derivedStateSignal = computed(() => {
+		if (state.loadingSuspended?.get()) return "dormant";
 		if (!context[loaderKey].get() || !selectedTrack.get()) return "preconditions-unmet";
 		if (state.loadActivated.get() || state.preload.get() === "auto") return "full-range";
 		if (state.preload.get() === "none") return "dormant";

package/dist/default/playback/behaviors/dom/load-segments.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"load-segments.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/load-segments.ts"],"sourcesContent":["/*\n Per-type segment loading dispatch. Per available track type (video /\n * audio / text), reads the per-type segment-loader actor from context and\n * sends typed `'load'` messages whenever a meaningful loading condition\n * changes (selected track, current time crossing a segment boundary).\n \n Loader-actor lifecycle is owned upstream:\n * - Video: `setupVideoBufferActors`\n * - Audio: `setupAudioBufferActors`\n * - Text: `setupTextTrackActors`\n \n This behavior is pure-consumer: it reads `context[loaderKey]` and\n * dispatches typed messages via the variant's per-type `findResolvedTrack`\n * resolver.\n \n # Load modes as reactor states\n \n Four states encode the load-gating policy directly:\n \n - `'preconditions-unmet'` — no loader actor in context, or the selected\n * track hasn't resolved.\n * - `'dormant'` — `preload === 'none' && !loadActivated`. Nothing fires.\n * - `'metadata-only'` — `!loadActivated && preload !== 'auto' && preload !== 'none'`.\n * Fires an init-segment-only `load` message once on entry. The\n * variant's loader actor decides what to do — v/a's actor fetches the\n * init segment; text's actor no-ops (no init concept).\n * - `'full-range'` — `loadActivated \|\| preload === 'auto'`. Effect re-fires\n * on selected-track change and on segment-boundary crossing.\n \n # Per-type parameterization (inference-driven)\n \n The helper is generic over `Track` — the resolved-track type. Each\n * variant supplies its own `findResolvedTrack` resolver via config; TS\n * infers `Track` from the resolver's return type. The loader signal's\n * value type is constrained to `SegmentLoaderLike<Track>` — anything with\n * a `send` method accepting the `Track`-parameterized message. Concrete\n * actor types (`SegmentLoaderActor`, `TextTrackSegmentLoaderActor`)\n * satisfy this via function-parameter contravariance: an actor whose\n * `.send` accepts a wider track type is assignable to a slot expecting a\n * narrower track type.\n \n No widening of actor message types is needed; no casts inside the\n * helper. Per-variant wiring (right loader paired with right resolver)\n * is enforced at the variant call site.\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, peek, type ReadonlySignal } from '../../../core/signals/primitives';\nimport {\n DEFAULT_FORWARD_BUFFER_CONFIG,\n type ForwardBufferConfig,\n segmentStartForTime,\n} from '../../../media/buffer/forward-buffer';\nimport type { MaybeResolvedPresentation, Segment } from '../../../media/types';\nimport { findResolvedAudioTrack, findResolvedTextTrack, findResolvedVideoTrack } from '../../../media/utils/tracks';\nimport type { BufferState, SegmentLoaderActor, SourceBufferState } from '../../actors/dom/segment-loader';\nimport type { TextTrackSegmentLoaderActor } from '../../actors/text-track-segment-loader';\nimport { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../track-types';\n\n// Re-export buffer state types for consumers that import them from this module.\nexport type { BufferState, SourceBufferState };\n\n// ============================================================================\n// STATE & CONTEXT\n// ============================================================================\n\n/* State shape for segment loading. /\nexport interface SegmentLoadingState {\n presentation?: MaybeResolvedPresentation;\n preload?: string;\n /* Current playback position in seconds. Defaults to 0 when undefined. /\n currentTime?: number;\n /* True once a preload-overriding event has fired for the current source. /\n loadActivated?: boolean;\n selectedVideoTrackId?: string;\n selectedAudioTrackId?: string;\n selectedTextTrackId?: string;\n}\n\n/* Context shape for segment loading. Each variant only consumes its own type's loader actor. /\nexport interface SegmentLoadingContext {\n videoSegmentLoaderActor?: SegmentLoaderActor;\n audioSegmentLoaderActor?: SegmentLoaderActor;\n textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor;\n}\n\n// ============================================================================\n// REACTOR\n// ============================================================================\n\ntype SegmentLoadingFsmState = 'preconditions-unmet' \| 'dormant' \| 'metadata-only' \| 'full-range';\n\ntype SelectedTrackKey = 'selectedVideoTrackId' \| 'selectedAudioTrackId' \| 'selectedTextTrackId';\ntype SegmentLoaderActorKey = 'videoSegmentLoaderActor' \| 'audioSegmentLoaderActor' \| 'textTrackSegmentLoaderActor';\n\ntype SegmentLoadingStateMap<K extends SelectedTrackKey> = {\n presentation: ReadonlySignal<SegmentLoadingState['presentation']>;\n preload: ReadonlySignal<SegmentLoadingState['preload']>;\n currentTime: ReadonlySignal<SegmentLoadingState['currentTime']>;\n loadActivated: ReadonlySignal<SegmentLoadingState['loadActivated']>;\n} & { [P in K]: ReadonlySignal<SegmentLoadingState[P]> };\n\n/* Shared `'load'` message shape parameterized over the resolved track type. /\ninterface LoadMessage<Track> {\n type: 'load';\n track: Track;\n range?: { start: number; end: number };\n}\n\n/* Structural constraint for any segment-loader-style actor. /\ninterface SegmentLoaderLike<Track> {\n send: (message: LoadMessage<Track>) => void;\n}\n\n/\n Specialization helper. Generic over `Track` (inferred from\n * `findResolvedTrack`'s return type). The loader value type is\n * constrained to `SegmentLoaderLike<Track>` — concrete actor types\n * (whose `.send` accepts a wider track union) satisfy this via\n * function-parameter contravariance.\n \n Tracks that the helper handles must have a `segments` field — used by\n * `segmentBoundarySignal` to compute the load-anchor boundary. Each\n * variant's resolver narrows to the right resolved-track shape.\n */\nfunction setupSegmentLoading<\n K extends SelectedTrackKey,\n L extends SegmentLoaderActorKey,\n Track extends { segments: readonly Segment[] },\n>({\n state,\n context,\n config,\n}: {\n state: SegmentLoadingStateMap<K>;\n context: { [P in L]: ReadonlySignal<SegmentLoaderLike<Track> \| undefined> };\n config: {\n selectedKey: K;\n loaderKey: L;\n findResolvedTrack: (\n presentation: MaybeResolvedPresentation \| undefined,\n trackId: string \| undefined\n ) => Track \| undefined;\n forwardBuffer?: Partial<ForwardBufferConfig>;\n };\n}): Reactor<SegmentLoadingFsmState \| 'destroying' \| 'destroyed'> {\n const { selectedKey, loaderKey, findResolvedTrack } = config;\n const bufferDuration = config.forwardBuffer?.bufferDuration ?? DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration;\n\n const selectedTrack = computed<Track \| undefined>(() =>\n findResolvedTrack(state.presentation.get(), state[selectedKey].get())\n );\n\n // Segment-boundary signal — `segmentStartForTime` returns the same number\n // while `currentTime` stays inside one segment, so signal-polyfill's\n // `Object.is` equality on this computed dedups within-segment ticks.\n const segmentBoundarySignal = computed(() => {\n const track = selectedTrack.get();\n if (!track) return undefined;\n return segmentStartForTime(state.currentTime.get() ?? 0, track.segments);\n });\n\n const derivedStateSignal = computed<SegmentLoadingFsmState>(() => {\n if (!context[loaderKey].get() \|\| !selectedTrack.get()) return 'preconditions-unmet';\n if (state.loadActivated.get() \|\| state.preload.get() === 'auto') return 'full-range';\n if (state.preload.get() === 'none') return 'dormant';\n return 'metadata-only';\n });\n\n return createMachineReactor<SegmentLoadingFsmState>({\n initial: 'preconditions-unmet',\n monitor: () => derivedStateSignal.get(),\n states: {\n 'preconditions-unmet': {},\n dormant: {},\n 'metadata-only': {\n // Fires once on entry. Matches HTMLMediaElement's preload='metadata'\n // semantics — load enough to surface metadata for the entry-time\n // selection. Each variant's loader decides what to do: v/a's actor\n // fetches the init segment; text's actor treats no-range as a\n // no-op. Selection changes while still in `'metadata-only'` are\n // intentionally not followed.\n entry: () => {\n const track = selectedTrack.get()!;\n context[loaderKey].get()!.send({ type: 'load', track });\n },\n },\n 'full-range': {\n // Re-fires on selected-track changes and on segment-boundary\n // crossings. The loader and `currentTime` are peeked — the\n // boundary-dedup signal already handles re-firing policy.\n effects: () => {\n const track = selectedTrack.get()!;\n segmentBoundarySignal.get();\n const currentTime = peek(state.currentTime) ?? 0;\n peek(context[loaderKey])!.send({\n type: 'load',\n track,\n range: { start: currentTime, end: currentTime + bufferDuration },\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_SEGMENT_LOADING_CONFIG = {\n ...VIDEO_TYPE_CONFIG,\n findResolvedTrack: findResolvedVideoTrack,\n} as const;\n\nconst AUDIO_SEGMENT_LOADING_CONFIG = {\n ...AUDIO_TYPE_CONFIG,\n findResolvedTrack: findResolvedAudioTrack,\n} as const;\n\nconst TEXT_SEGMENT_LOADING_CONFIG = {\n ...TEXT_TYPE_CONFIG,\n findResolvedTrack: findResolvedTextTrack,\n} as const;\n\n// ============================================================================\n// Specialized exports — one per media type\n// ============================================================================\n\nexport const loadVideoSegments = defineBehavior({\n stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedVideoTrackId'],\n contextKeys: ['videoSegmentLoaderActor'],\n setup: ({\n state,\n context,\n config = {},\n }: {\n state: SegmentLoadingStateMap<'selectedVideoTrackId'>;\n context: {\n videoSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['videoSegmentLoaderActor']>;\n };\n config?: object;\n }) =>\n setupSegmentLoading({\n state,\n context,\n config: { ...VIDEO_SEGMENT_LOADING_CONFIG, ...config },\n }),\n});\n\nexport const loadAudioSegments = defineBehavior({\n stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedAudioTrackId'],\n contextKeys: ['audioSegmentLoaderActor'],\n setup: ({\n state,\n context,\n config = {},\n }: {\n state: SegmentLoadingStateMap<'selectedAudioTrackId'>;\n context: {\n audioSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['audioSegmentLoaderActor']>;\n };\n config?: object;\n }) =>\n setupSegmentLoading({\n state,\n context,\n config: { ...AUDIO_SEGMENT_LOADING_CONFIG, ...config },\n }),\n});\n\nexport const loadTextTrackSegments = defineBehavior({\n stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedTextTrackId'],\n contextKeys: ['textTrackSegmentLoaderActor'],\n setup: ({\n state,\n context,\n config = {},\n }: {\n state: SegmentLoadingStateMap<'selectedTextTrackId'>;\n context: {\n textTrackSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['textTrackSegmentLoaderActor']>;\n };\n config?: object;\n }) =>\n setupSegmentLoading({\n state,\n context,\n config: { ...TEXT_SEGMENT_LOADING_CONFIG, ...config },\n }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8HA,SAAS,oBAIP,EACA,OACA,SACA,UAa+D;CAC/D,MAAM,EAAE,aAAa,WAAW,sBAAsB;CACtD,MAAM,iBAAiB,OAAO,eAAe,kBAAkB,8BAA8B;CAE7F,MAAM,gBAAgB,eACpB,kBAAkB,MAAM,aAAa,KAAK,EAAE,MAAM,aAAa,KAAK,CAAC,CACtE;CAKD,MAAM,wBAAwB,eAAe;EAC3C,MAAM,QAAQ,cAAc,KAAK;AACjC,MAAI,CAAC,MAAO,QAAO,KAAA;AACnB,SAAO,oBAAoB,MAAM,YAAY,KAAK,IAAI,GAAG,MAAM,SAAS;GACxE;CAEF,MAAM,qBAAqB,eAAuC;AAChE,MAAI,CAAC,QAAQ,WAAW,KAAK,IAAI,CAAC,cAAc,KAAK,CAAE,QAAO;AAC9D,MAAI,MAAM,cAAc,KAAK,IAAI,MAAM,QAAQ,KAAK,KAAK,OAAQ,QAAO;AACxE,MAAI,MAAM,QAAQ,KAAK,KAAK,OAAQ,QAAO;AAC3C,SAAO;GACP;AAEF,QAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GACzB,SAAS,EAAE;GACX,iBAAiB,EAOf,aAAa;IACX,MAAM,QAAQ,cAAc,KAAK;AACjC,YAAQ,WAAW,KAAK,CAAE,KAAK;KAAE,MAAM;KAAQ;KAAO,CAAC;MAE1D;GACD,cAAc,EAIZ,eAAe;IACb,MAAM,QAAQ,cAAc,KAAK;AACjC,0BAAsB,KAAK;IAC3B,MAAM,cAAc,KAAK,MAAM,YAAY,IAAI;AAC/C,SAAK,QAAQ,WAAW,CAAE,KAAK;KAC7B,MAAM;KACN;KACA,OAAO;MAAE,OAAO;MAAa,KAAK,cAAc;MAAgB;KACjE,CAAC;MAEL;GACF;EACF,CAAC;;AAOJ,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;CACpB;AAED,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;CACpB;AAED,MAAM,8BAA8B;CAClC,GAAG;CACH,mBAAmB;CACpB;AAMD,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAuB;CAC9F,aAAa,CAAC,0BAA0B;CACxC,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;GAAQ;EACvD,CAAC;CACL,CAAC;AAEF,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAuB;CAC9F,aAAa,CAAC,0BAA0B;CACxC,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;GAAQ;EACvD,CAAC;CACL,CAAC;AAEF,MAAa,wBAAwB,eAAe;CAClD,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAsB;CAC7F,aAAa,CAAC,8BAA8B;CAC5C,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA6B,GAAG;GAAQ;EACtD,CAAC;CACL,CAAC"}
1	+ {"version":3,"file":"load-segments.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/load-segments.ts"],"sourcesContent":["/*\n Per-type segment loading dispatch. Per available track type (video /\n * audio / text), reads the per-type segment-loader actor from context and\n * sends typed `'load'` messages whenever a meaningful loading condition\n * changes (selected track, current time crossing a segment boundary).\n \n Loader-actor lifecycle is owned upstream:\n * - Video: `setupVideoBufferActors`\n * - Audio: `setupAudioBufferActors`\n * - Text: `setupTextTrackActors`\n \n This behavior is pure-consumer: it reads `context[loaderKey]` and\n * dispatches typed messages via the variant's per-type `findResolvedTrack`\n * resolver.\n \n # Load modes as reactor states\n \n Four states encode the load-gating policy directly:\n \n - `'preconditions-unmet'` — no loader actor in context, or the selected\n * track hasn't resolved.\n * - `'dormant'` — loading disabled by policy: an observed `loadingSuspended`\n * (highest precedence) or `preload === 'none' && !loadActivated`. Nothing\n * fires; already-queued loader work drains. Auto-resumes into the derived\n * state when the policy lifts.\n * - `'metadata-only'` — `!loadActivated && preload !== 'auto' && preload !== 'none'`.\n * Fires an init-segment-only `load` message once on entry. The\n * variant's loader actor decides what to do — v/a's actor fetches the\n * init segment; text's actor no-ops (no init concept).\n * - `'full-range'` — `loadActivated \|\| preload === 'auto'`. Effect re-fires\n * on selected-track change and on segment-boundary crossing.\n \n # Per-type parameterization (inference-driven)\n \n The helper is generic over `Track` — the resolved-track type. Each\n * variant supplies its own `findResolvedTrack` resolver via config; TS\n * infers `Track` from the resolver's return type. The loader signal's\n * value type is constrained to `SegmentLoaderLike<Track>` — anything with\n * a `send` method accepting the `Track`-parameterized message. Concrete\n * actor types (`SegmentLoaderActor`, `TextTrackSegmentLoaderActor`)\n * satisfy this via function-parameter contravariance: an actor whose\n * `.send` accepts a wider track type is assignable to a slot expecting a\n * narrower track type.\n \n No widening of actor message types is needed; no casts inside the\n * helper. Per-variant wiring (right loader paired with right resolver)\n * is enforced at the variant call site.\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, peek, type ReadonlySignal } from '../../../core/signals/primitives';\nimport {\n DEFAULT_FORWARD_BUFFER_CONFIG,\n type ForwardBufferConfig,\n segmentStartForTime,\n} from '../../../media/buffer/forward-buffer';\nimport type { MaybeResolvedPresentation, Segment } from '../../../media/types';\nimport { findResolvedAudioTrack, findResolvedTextTrack, findResolvedVideoTrack } from '../../../media/utils/tracks';\nimport type { BufferState, SegmentLoaderActor, SourceBufferState } from '../../actors/dom/segment-loader';\nimport type { TextTrackSegmentLoaderActor } from '../../actors/text-track-segment-loader';\nimport { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../../primitives/track-types';\n\n// Re-export buffer state types for consumers that import them from this module.\nexport type { BufferState, SourceBufferState };\n\n// ============================================================================\n// STATE & CONTEXT\n// ============================================================================\n\n/* State shape for segment loading. /\nexport interface SegmentLoadingState {\n presentation?: MaybeResolvedPresentation;\n preload?: string;\n /* Current playback position in seconds. Defaults to 0 when undefined. /\n currentTime?: number;\n /* True once a preload-overriding event has fired for the current source. /\n loadActivated?: boolean;\n /\n Intent-level policy input: initiate no new loading work while `true`.\n * Read here by the `loadXSegments` dispatchers (park in `'dormant'`,\n * highest precedence) and by `setupMediaSource` (a pending MediaSource\n * rebuild waits — attach runs the element's load algorithm). *Observed,\n never declared*: no reader lists this key in `stateKeys`, so the slot\n exists only in compositions where a feature behavior declares and\n * writes it (e.g. `setupAirPlay`, while a remote-playback session owns\n * presentation). An absent slot means never suspended.\n /\n loadingSuspended?: boolean;\n selectedVideoTrackId?: string;\n selectedAudioTrackId?: string;\n selectedTextTrackId?: string;\n}\n\n/* Context shape for segment loading. Each variant only consumes its own type's loader actor. /\nexport interface SegmentLoadingContext {\n videoSegmentLoaderActor?: SegmentLoaderActor;\n audioSegmentLoaderActor?: SegmentLoaderActor;\n textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor;\n}\n\n// ============================================================================\n// REACTOR\n// ============================================================================\n\ntype SegmentLoadingFsmState = 'preconditions-unmet' \| 'dormant' \| 'metadata-only' \| 'full-range';\n\ntype SelectedTrackKey = 'selectedVideoTrackId' \| 'selectedAudioTrackId' \| 'selectedTextTrackId';\ntype SegmentLoaderActorKey = 'videoSegmentLoaderActor' \| 'audioSegmentLoaderActor' \| 'textTrackSegmentLoaderActor';\n\ntype SegmentLoadingStateMap<K extends SelectedTrackKey> = {\n presentation: ReadonlySignal<SegmentLoadingState['presentation']>;\n preload: ReadonlySignal<SegmentLoadingState['preload']>;\n currentTime: ReadonlySignal<SegmentLoadingState['currentTime']>;\n loadActivated: ReadonlySignal<SegmentLoadingState['loadActivated']>;\n} & { [P in K]: ReadonlySignal<SegmentLoadingState[P]> };\n\n/* Shared `'load'` message shape parameterized over the resolved track type. /\ninterface LoadMessage<Track> {\n type: 'load';\n track: Track;\n range?: { start: number; end: number };\n}\n\n/* Structural constraint for any segment-loader-style actor. /\ninterface SegmentLoaderLike<Track> {\n send: (message: LoadMessage<Track>) => void;\n}\n\n/\n Specialization helper. Generic over `Track` (inferred from\n * `findResolvedTrack`'s return type). The loader value type is\n * constrained to `SegmentLoaderLike<Track>` — concrete actor types\n * (whose `.send` accepts a wider track union) satisfy this via\n * function-parameter contravariance.\n \n Tracks that the helper handles must have a `segments` field — used by\n * `segmentBoundarySignal` to compute the load-anchor boundary. Each\n * variant's resolver narrows to the right resolved-track shape.\n */\nfunction setupSegmentLoading<\n K extends SelectedTrackKey,\n L extends SegmentLoaderActorKey,\n Track extends { segments: readonly Segment[] },\n>({\n state,\n context,\n config,\n}: {\n // `loadingSuspended` is observed, never declared (see its state-shape doc):\n // optional here so variant maps — which omit it from their contracts — are\n // assignable as-is, while compositions with a writer expose the live slot.\n state: SegmentLoadingStateMap<K> & { loadingSuspended?: ReadonlySignal<SegmentLoadingState['loadingSuspended']> };\n context: { [P in L]: ReadonlySignal<SegmentLoaderLike<Track> \| undefined> };\n config: {\n selectedKey: K;\n loaderKey: L;\n findResolvedTrack: (\n presentation: MaybeResolvedPresentation \| undefined,\n trackId: string \| undefined\n ) => Track \| undefined;\n forwardBuffer?: Partial<ForwardBufferConfig>;\n };\n}): Reactor<SegmentLoadingFsmState \| 'destroying' \| 'destroyed'> {\n const { selectedKey, loaderKey, findResolvedTrack } = config;\n const bufferDuration = config.forwardBuffer?.bufferDuration ?? DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration;\n\n const selectedTrack = computed<Track \| undefined>(() =>\n findResolvedTrack(state.presentation.get(), state[selectedKey].get())\n );\n\n // Segment-boundary signal — `segmentStartForTime` returns the same number\n // while `currentTime` stays inside one segment, so signal-polyfill's\n // `Object.is` equality on this computed dedups within-segment ticks.\n const segmentBoundarySignal = computed(() => {\n const track = selectedTrack.get();\n if (!track) return undefined;\n return segmentStartForTime(state.currentTime.get() ?? 0, track.segments);\n });\n\n const derivedStateSignal = computed<SegmentLoadingFsmState>(() => {\n // Policy-off wins even over preconditions: a loader arriving while\n // suspended must not dispatch.\n if (state.loadingSuspended?.get()) return 'dormant';\n if (!context[loaderKey].get() \|\| !selectedTrack.get()) return 'preconditions-unmet';\n if (state.loadActivated.get() \|\| state.preload.get() === 'auto') return 'full-range';\n if (state.preload.get() === 'none') return 'dormant';\n return 'metadata-only';\n });\n\n return createMachineReactor<SegmentLoadingFsmState>({\n initial: 'preconditions-unmet',\n monitor: () => derivedStateSignal.get(),\n states: {\n 'preconditions-unmet': {},\n dormant: {},\n 'metadata-only': {\n // Fires once on entry. Matches HTMLMediaElement's preload='metadata'\n // semantics — load enough to surface metadata for the entry-time\n // selection. Each variant's loader decides what to do: v/a's actor\n // fetches the init segment; text's actor treats no-range as a\n // no-op. Selection changes while still in `'metadata-only'` are\n // intentionally not followed.\n entry: () => {\n const track = selectedTrack.get()!;\n context[loaderKey].get()!.send({ type: 'load', track });\n },\n },\n 'full-range': {\n // Re-fires on selected-track changes and on segment-boundary\n // crossings. The loader and `currentTime` are peeked — the\n // boundary-dedup signal already handles re-firing policy.\n effects: () => {\n const track = selectedTrack.get()!;\n segmentBoundarySignal.get();\n const currentTime = peek(state.currentTime) ?? 0;\n peek(context[loaderKey])!.send({\n type: 'load',\n track,\n range: { start: currentTime, end: currentTime + bufferDuration },\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_SEGMENT_LOADING_CONFIG = {\n ...VIDEO_TYPE_CONFIG,\n findResolvedTrack: findResolvedVideoTrack,\n} as const;\n\nconst AUDIO_SEGMENT_LOADING_CONFIG = {\n ...AUDIO_TYPE_CONFIG,\n findResolvedTrack: findResolvedAudioTrack,\n} as const;\n\nconst TEXT_SEGMENT_LOADING_CONFIG = {\n ...TEXT_TYPE_CONFIG,\n findResolvedTrack: findResolvedTextTrack,\n} as const;\n\n// ============================================================================\n// Specialized exports — one per media type\n// ============================================================================\n\nexport const loadVideoSegments = defineBehavior({\n stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedVideoTrackId'],\n contextKeys: ['videoSegmentLoaderActor'],\n setup: ({\n state,\n context,\n config = {},\n }: {\n state: SegmentLoadingStateMap<'selectedVideoTrackId'>;\n context: {\n videoSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['videoSegmentLoaderActor']>;\n };\n config?: object;\n }) =>\n setupSegmentLoading({\n state,\n context,\n config: { ...VIDEO_SEGMENT_LOADING_CONFIG, ...config },\n }),\n});\n\nexport const loadAudioSegments = defineBehavior({\n stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedAudioTrackId'],\n contextKeys: ['audioSegmentLoaderActor'],\n setup: ({\n state,\n context,\n config = {},\n }: {\n state: SegmentLoadingStateMap<'selectedAudioTrackId'>;\n context: {\n audioSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['audioSegmentLoaderActor']>;\n };\n config?: object;\n }) =>\n setupSegmentLoading({\n state,\n context,\n config: { ...AUDIO_SEGMENT_LOADING_CONFIG, ...config },\n }),\n});\n\nexport const loadTextTrackSegments = defineBehavior({\n stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedTextTrackId'],\n contextKeys: ['textTrackSegmentLoaderActor'],\n setup: ({\n state,\n context,\n config = {},\n }: {\n state: SegmentLoadingStateMap<'selectedTextTrackId'>;\n context: {\n textTrackSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['textTrackSegmentLoaderActor']>;\n };\n config?: object;\n }) =>\n setupSegmentLoading({\n state,\n context,\n config: { ...TEXT_SEGMENT_LOADING_CONFIG, ...config },\n }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4IA,SAAS,oBAIP,EACA,OACA,SACA,UAgB+D;CAC/D,MAAM,EAAE,aAAa,WAAW,sBAAsB;CACtD,MAAM,iBAAiB,OAAO,eAAe,kBAAkB,8BAA8B;CAE7F,MAAM,gBAAgB,eACpB,kBAAkB,MAAM,aAAa,IAAI,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,CACtE;CAKA,MAAM,wBAAwB,eAAe;EAC3C,MAAM,QAAQ,cAAc,IAAI;EAChC,IAAI,CAAC,OAAO,OAAO,KAAA;EACnB,OAAO,oBAAoB,MAAM,YAAY,IAAI,KAAK,GAAG,MAAM,QAAQ;CACzE,CAAC;CAED,MAAM,qBAAqB,eAAuC;EAGhE,IAAI,MAAM,kBAAkB,IAAI,GAAG,OAAO;EAC1C,IAAI,CAAC,QAAQ,UAAU,CAAC,IAAI,KAAK,CAAC,cAAc,IAAI,GAAG,OAAO;EAC9D,IAAI,MAAM,cAAc,IAAI,KAAK,MAAM,QAAQ,IAAI,MAAM,QAAQ,OAAO;EACxE,IAAI,MAAM,QAAQ,IAAI,MAAM,QAAQ,OAAO;EAC3C,OAAO;CACT,CAAC;CAED,OAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,CAAC;GACxB,SAAS,CAAC;GACV,iBAAiB,EAOf,aAAa;IACX,MAAM,QAAQ,cAAc,IAAI;IAChC,QAAQ,UAAU,CAAC,IAAI,CAAC,CAAE,KAAK;KAAE,MAAM;KAAQ;IAAM,CAAC;GACxD,EACF;GACA,cAAc,EAIZ,eAAe;IACb,MAAM,QAAQ,cAAc,IAAI;IAChC,sBAAsB,IAAI;IAC1B,MAAM,cAAc,KAAK,MAAM,WAAW,KAAK;IAC/C,KAAK,QAAQ,UAAU,CAAC,CAAE,KAAK;KAC7B,MAAM;KACN;KACA,OAAO;MAAE,OAAO;MAAa,KAAK,cAAc;KAAe;IACjE,CAAC;GACH,EACF;EACF;CACF,CAAC;AACH;AAMA,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;AACrB;AAEA,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;AACrB;AAEA,MAAM,8BAA8B;CAClC,GAAG;CACH,mBAAmB;AACrB;AAMA,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;CAAsB;CAC7F,aAAa,CAAC,yBAAyB;CACvC,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QAQV,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;EAAO;CACvD,CAAC;AACL,CAAC;AAED,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;CAAsB;CAC7F,aAAa,CAAC,yBAAyB;CACvC,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QAQV,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;EAAO;CACvD,CAAC;AACL,CAAC;AAED,MAAa,wBAAwB,eAAe;CAClD,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;CAAqB;CAC5F,aAAa,CAAC,6BAA6B;CAC3C,QAAQ,EACN,OACA,SACA,SAAS,CAAC,QAQV,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA6B,GAAG;EAAO;CACtD,CAAC;AACL,CAAC"}

package/dist/default/playback/behaviors/dom/recover-end-stall.js ADDED Viewed

@@ -0,0 +1,77 @@
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { getMinBufferedEnd } from "../../../media/dom/mse/duration.js";
+import { listen } from "@videojs/utils/dom";
+//#region src/playback/behaviors/dom/recover-end-stall.ts
+/**
+* Recover the end-of-stream stall that Chrome exhibits on skewed A/V. After
+* `endOfStream`, when the audio and video tracks end a few ms apart (e.g. a source
+* with an A/V PTS skew), Chrome's audio-clock-paced playback freezes the playhead
+* ~50–70ms short of the reachable buffered end and never fires `ended` — so playback
+* hangs at the very end and loop never re-triggers. This behavior watches for the
+* `waiting` event that fires at that freeze and, when the MediaSource is `ended` and
+* the playhead sits at the reachable buffered end, nudges `currentTime` to `duration`
+* to force the native `ended`.
+*
+* **Event-driven, no poll.** `waiting` fires at the instant the playhead stalls
+* (measured ~0ms latency), so there's nothing to gain from polling — and polling would
+* add its interval + a stall threshold before reacting.
+*
+* **Proximity to the *reachable* buffered end** is the discriminator. That end is
+* `getMinBufferedEnd(mediaSource.sourceBuffers)` — the `min` of the per-track (video/audio)
+* SourceBuffer ends, i.e. the furthest point playback can reach — read from the SourceBuffers
+* directly rather than the `mediaElement.buffered` aggregate. Once `endOfStream` is signalled
+* that's the true content end. Requiring the playhead within `endStallNudgeWindow` of it
+* distinguishes the real end-of-stream freeze from a mid-stream buffer-hole stall (which sits
+* far from the buffered end), so we never skip content. The window must exceed the freeze gap;
+* too small would miss the stall (a permanent hang), so the default is generous relative to the
+* measured gap and is config-tunable for empirical tuning.
+*
+* Inert where it shouldn't act: live (the MediaSource never reaches `ended` while the
+* window grows; `duration` is `Infinity`) and streams that end cleanly (no `waiting`).
+*
+* See `internal/decisions/spf/end-of-stream-av-skew-recovery.md`.
+*/
+/** ~2.8× the measured max freeze gap (71ms) — tight, but with headroom against a miss. */
+const DEFAULT_END_STALL_NUDGE_WINDOW = .2;
+/**
+* Whether a `waiting` should be forced to `ended`: the MediaSource is `ended`, the
+* stream is finite (not live), playback is active (not paused/seeking/already-ended),
+* and the playhead sits within `nudgeWindow` of the reachable buffered end (so it's the
+* true end, not a mid-stream buffer hole). Pure — the behavior supplies the live values.
+*/
+function shouldForceEnded(input, nudgeWindow) {
+	const { msEnded, durationFinite, paused, seeking, ended, currentTime, bufferedEnd } = input;
+	if (!msEnded || !durationFinite || paused || seeking || ended || bufferedEnd === void 0) return false;
+	const gap = bufferedEnd - currentTime;
+	return gap >= 0 && gap < nudgeWindow;
+}
+function recoverEndStallSetup({ context, config }) {
+	const nudgeWindow = config?.endStallNudgeWindow ?? .2;
+	return effect(() => {
+		const mediaElement = context.mediaElement.get();
+		if (!mediaElement) return;
+		const onWaiting = () => {
+			const mediaSource = context.mediaSource.get();
+			if (shouldForceEnded({
+				msEnded: mediaSource?.readyState === "ended",
+				durationFinite: Number.isFinite(mediaElement.duration),
+				paused: mediaElement.paused,
+				seeking: mediaElement.seeking,
+				ended: mediaElement.ended,
+				currentTime: mediaElement.currentTime,
+				bufferedEnd: mediaSource ? getMinBufferedEnd(mediaSource.sourceBuffers) : void 0
+			}, nudgeWindow)) mediaElement.currentTime = mediaElement.duration;
+		};
+		return listen(mediaElement, "waiting", onWaiting);
+	});
+}
+const recoverEndStall = defineBehavior({
+	stateKeys: [],
+	contextKeys: ["mediaElement", "mediaSource"],
+	setup: recoverEndStallSetup
+});
+//#endregion
+export { DEFAULT_END_STALL_NUDGE_WINDOW, recoverEndStall, shouldForceEnded };
+//# sourceMappingURL=recover-end-stall.js.map

package/dist/default/playback/behaviors/dom/recover-end-stall.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"recover-end-stall.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/recover-end-stall.ts"],"sourcesContent":["/**\n * Recover the end-of-stream stall that Chrome exhibits on skewed A/V. After\n * `endOfStream`, when the audio and video tracks end a few ms apart (e.g. a source\n * with an A/V PTS skew), Chrome's audio-clock-paced playback freezes the playhead\n * ~50–70ms short of the reachable buffered end and never fires `ended` — so playback\n * hangs at the very end and loop never re-triggers. This behavior watches for the\n * `waiting` event that fires at that freeze and, when the MediaSource is `ended` and\n * the playhead sits at the reachable buffered end, nudges `currentTime` to `duration`\n * to force the native `ended`.\n *\n * **Event-driven, no poll.** `waiting` fires at the instant the playhead stalls\n * (measured ~0ms latency), so there's nothing to gain from polling — and polling would\n * add its interval + a stall threshold before reacting.\n *\n * **Proximity to the *reachable* buffered end** is the discriminator. That end is\n * `getMinBufferedEnd(mediaSource.sourceBuffers)` — the `min` of the per-track (video/audio)\n * SourceBuffer ends, i.e. the furthest point playback can reach — read from the SourceBuffers\n * directly rather than the `mediaElement.buffered` aggregate. Once `endOfStream` is signalled\n * that's the true content end. Requiring the playhead within `endStallNudgeWindow` of it\n * distinguishes the real end-of-stream freeze from a mid-stream buffer-hole stall (which sits\n * far from the buffered end), so we never skip content. The window must exceed the freeze gap;\n * too small would miss the stall (a permanent hang), so the default is generous relative to the\n * measured gap and is config-tunable for empirical tuning.\n *\n * Inert where it shouldn't act: live (the MediaSource never reaches `ended` while the\n * window grows; `duration` is `Infinity`) and streams that end cleanly (no `waiting`).\n *\n * See `internal/decisions/spf/end-of-stream-av-skew-recovery.md`.\n */\nimport { listen } from '@videojs/utils/dom';\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal } from '../../../core/signals/primitives';\nimport { getMinBufferedEnd } from '../../../media/dom/mse/duration';\n\nexport interface RecoverEndStallContext {\n mediaElement?: HTMLMediaElement | undefined;\n mediaSource?: MediaSource | undefined;\n}\n\nexport interface RecoverEndStallConfig {\n /**\n * How close (seconds) the playhead must be to the reachable buffered end for a\n * `waiting` to count as the end-of-stream freeze. Must exceed the audio-clock freeze\n * gap (~50–70ms measured on Chrome); too small risks missing the stall (a permanent\n * hang), so keep a margin. Default {@link DEFAULT_END_STALL_NUDGE_WINDOW}.\n */\n endStallNudgeWindow?: number;\n}\n\n/** ~2.8× the measured max freeze gap (71ms) — tight, but with headroom against a miss. */\nexport const DEFAULT_END_STALL_NUDGE_WINDOW = 0.2;\n\n/**\n * Whether a `waiting` should be forced to `ended`: the MediaSource is `ended`, the\n * stream is finite (not live), playback is active (not paused/seeking/already-ended),\n * and the playhead sits within `nudgeWindow` of the reachable buffered end (so it's the\n * true end, not a mid-stream buffer hole). Pure — the behavior supplies the live values.\n */\nexport function shouldForceEnded(\n input: {\n msEnded: boolean;\n durationFinite: boolean;\n paused: boolean;\n seeking: boolean;\n ended: boolean;\n currentTime: number;\n bufferedEnd: number | undefined;\n },\n nudgeWindow: number\n): boolean {\n const { msEnded, durationFinite, paused, seeking, ended, currentTime, bufferedEnd } = input;\n if (!msEnded || !durationFinite || paused || seeking || ended || bufferedEnd === undefined) {\n return false;\n }\n const gap = bufferedEnd - currentTime;\n return gap >= 0 && gap < nudgeWindow;\n}\n\nfunction recoverEndStallSetup({\n context,\n config,\n}: {\n context: {\n mediaElement: ReadonlySignal<RecoverEndStallContext['mediaElement']>;\n mediaSource: ReadonlySignal<RecoverEndStallContext['mediaSource']>;\n };\n config?: RecoverEndStallConfig;\n}): () => void {\n const nudgeWindow = config?.endStallNudgeWindow ?? DEFAULT_END_STALL_NUDGE_WINDOW;\n\n return effect(() => {\n const mediaElement = context.mediaElement.get();\n if (!mediaElement) return;\n\n const onWaiting = () => {\n const mediaSource = context.mediaSource.get();\n const forceEnded = shouldForceEnded(\n {\n msEnded: mediaSource?.readyState === 'ended',\n durationFinite: Number.isFinite(mediaElement.duration),\n paused: mediaElement.paused,\n seeking: mediaElement.seeking,\n ended: mediaElement.ended,\n currentTime: mediaElement.currentTime,\n bufferedEnd: mediaSource ? getMinBufferedEnd(mediaSource.sourceBuffers) : undefined,\n },\n nudgeWindow\n );\n // Nudge to `duration` → native `ended` (the seeking/ended guards above prevent a\n // re-fire while the nudge-seek is in flight, so no latch is needed).\n if (forceEnded) mediaElement.currentTime = mediaElement.duration;\n };\n\n return listen(mediaElement, 'waiting', onWaiting);\n });\n}\n\nexport const recoverEndStall = defineBehavior({\n stateKeys: [] as const,\n contextKeys: ['mediaElement', 'mediaSource'] as const,\n setup: recoverEndStallSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,MAAa,iCAAiC;;;;;;;AAQ9C,SAAgB,iBACd,OASA,aACS;CACT,MAAM,EAAE,SAAS,gBAAgB,QAAQ,SAAS,OAAO,aAAa,gBAAgB;CACtF,IAAI,CAAC,WAAW,CAAC,kBAAkB,UAAU,WAAW,SAAS,gBAAgB,KAAA,GAC/E,OAAO;CAET,MAAM,MAAM,cAAc;CAC1B,OAAO,OAAO,KAAK,MAAM;AAC3B;AAEA,SAAS,qBAAqB,EAC5B,SACA,UAOa;CACb,MAAM,cAAc,QAAQ,uBAAA;CAE5B,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAC9C,IAAI,CAAC,cAAc;EAEnB,MAAM,kBAAkB;GACtB,MAAM,cAAc,QAAQ,YAAY,IAAI;GAe5C,IAdmB,iBACjB;IACE,SAAS,aAAa,eAAe;IACrC,gBAAgB,OAAO,SAAS,aAAa,QAAQ;IACrD,QAAQ,aAAa;IACrB,SAAS,aAAa;IACtB,OAAO,aAAa;IACpB,aAAa,aAAa;IAC1B,aAAa,cAAc,kBAAkB,YAAY,aAAa,IAAI,KAAA;GAC5E,GACA,WAIW,GAAG,aAAa,cAAc,aAAa;EAC1D;EAEA,OAAO,OAAO,cAAc,WAAW,SAAS;CAClD,CAAC;AACH;AAEA,MAAa,kBAAkB,eAAe;CAC5C,WAAW,CAAC;CACZ,aAAa,CAAC,gBAAgB,aAAa;CAC3C,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/setup-buffer-actors.js CHANGED Viewed

@@ -2,12 +2,14 @@ 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 { hasCodecs } from "../../../media/utils/tracks.js";
-import { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../track-types.js";
-import { getSelectedTrack } from "../../../media/utils/track-selection.js";
+import { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../../primitives/track-types.js";
 import { buildMimeCodec, createSourceBuffer } from "../../../media/dom/mse/mediasource-setup.js";
+import { getSelectedTrack } from "../../../media/utils/track-selection.js";
 import { createTrackedFetch, fetchStream } from "../../../network/fetch.js";
 import { createSegmentLoaderActor } from "../../actors/dom/segment-loader.js";
 import { createSourceBufferActor } from "../../actors/dom/source-buffer.js";
+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
@@ -39,7 +41,7 @@ import { createSourceBufferActor } from "../../actors/dom/source-buffer.js";
 * with its upstream and downstream siblings:
 *
 * 1. **Upstream — default selections land in one `runPending`.**
-*    `selectAudioTrack` (default audio) and `switchVideoQuality`
+*    `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.
@@ -71,7 +73,7 @@ import { createSourceBufferActor } from "../../actors/dom/source-buffer.js";
 * `updateMediaSourceDuration`) only read these slots.
 */
 function setupBufferActors({ state, context, config }) {
-	const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer } = config;
+	const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer, messagePipelines } = config;
 	const derivedStateSignal = computed(() => {
 		if (!context.mediaSource.get()) return "preconditions-unmet";
 		return hasCodecs(getSelectedTrack({
@@ -85,22 +87,32 @@ function setupBufferActors({ state, context, config }) {
 		states: {
 			"preconditions-unmet": {},
 			"buffer-ready": { entry: () => {
-				const bufferActor = createSourceBufferActor(createSourceBuffer(context.mediaSource.get(), buildMimeCodec(getSelectedTrack({
+				const mediaSource = context.mediaSource.get();
+				const bufferActor = createSourceBufferActor(createSourceBuffer(mediaSource, buildMimeCodec(getSelectedTrack({
 					presentation: state.presentation.get(),
 					[selectedKey]: state[selectedKey].get()
 				}, type))));
 				const segmentLoader = createSegmentLoaderActor(bufferActor, fetch, {
 					forwardBuffer,
-					backBuffer
+					backBuffer,
+					messagePipelines
+				}, {
+					state,
+					context,
+					config
 				});
 				context[actorKey].set(bufferActor);
 				context[loaderKey].set(segmentLoader);
-				return () => {
+				const disconnect = new AbortController();
+				const teardownActors = () => {
 					segmentLoader.destroy();
 					bufferActor.destroy();
 					context[loaderKey].set(void 0);
 					context[actorKey].set(void 0);
+					disconnect.abort();
 				};
+				listen(mediaSource, "sourceclose", teardownActors, { signal: disconnect.signal });
+				return teardownActors;
 			} }
 		}
 	});
@@ -131,13 +143,17 @@ const setupVideoBufferActors = defineBehavior({
 			slowTotalWeight: 0,
 			bytesSampled: 0
 		}, (next) => state.bandwidthState.set(next));
+		const typeConfig = {
+			...VIDEO_TYPE_CONFIG,
+			...config
+		};
 		return setupBufferActors({
 			state,
 			context,
 			config: {
-				...VIDEO_TYPE_CONFIG,
-				fetch: trackedFetch,
-				...config
+				...typeConfig,
+				messagePipelines: config.videoMessagePipelines,
+				fetch: failoverFetch(trackedFetch, state, typeConfig)
 			}
 		});
 	}
@@ -148,7 +164,17 @@ const setupVideoBufferActors = defineBehavior({
 * 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.
+* 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.
 */
 const setupAudioBufferActors = defineBehavior({
 	stateKeys: ["presentation", "selectedAudioTrackId"],
@@ -157,15 +183,21 @@ const setupAudioBufferActors = defineBehavior({
 		"audioBufferActor",
 		"audioSegmentLoaderActor"
 	],
-	setup: ({ state, context, config = {} }) => setupBufferActors({
-		state,
-		context,
-		config: {
+	setup: ({ state, context, config = {} }) => {
+		const typeConfig = {
 			...AUDIO_TYPE_CONFIG,
-			fetch: fetchStream,
 			...config
-		}
-	})
+		};
+		return setupBufferActors({
+			state,
+			context,
+			config: {
+				...typeConfig,
+				messagePipelines: config.audioMessagePipelines,
+				fetch: failoverFetch(fetchStream, state, typeConfig)
+			}
+		});
+	}
 });
 //#endregion
 export { setupAudioBufferActors, setupVideoBufferActors };

package/dist/default/playback/behaviors/dom/setup-buffer-actors.js.map CHANGED Viewed

	@@ -1 +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 `switchVideoQuality`\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 { 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 { 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 { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../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 } = 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(bufferActor, fetch, { forwardBuffer, backBuffer });\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.\n return () => {\n segmentLoader.destroy();\n bufferActor.destroy();\n context[loaderKey].set(undefined);\n context[actorKey].set(undefined);\n };\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?: object;\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 return setupBufferActors({\n state,\n context,\n config: { ...VIDEO_TYPE_CONFIG, fetch: trackedFetch, ...config },\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.\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?: object;\n }) =>\n setupBufferActors({\n state,\n context,\n config: { ...AUDIO_TYPE_CONFIG, fetch: fetchStream, ...config },\n }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmIA,SAAS,kBAAyG,EAChH,OACA,SACA,UAW6D;CAC7D,MAAM,EAAE,MAAM,aAAa,UAAU,WAAW,OAAO,eAAe,eAAe;CACrF,MAAM,qBAAqB,eAAqC;AAC9D,MAAI,CAAC,QAAQ,YAAY,KAAK,CAAE,QAAO;AAKvC,SAAO,UAAU,iBAJsB;GACrC,cAAc,MAAM,aAAa,KAAK;IACrC,cAAc,MAAM,aAAa,KAAK;GACxC,EAC4C,KAAK,CAAC,GAAG,iBAAiB;GACvE;AAEF,QAAO,qBAA2C;EAChD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,gBAAgB,EACd,aAAa;IAQX,MAAM,cAAc,wBADL,mBANK,QAAQ,YAAY,KAAK,EAME,eADjC,iBAJyB;KACrC,cAAc,MAAM,aAAa,KAAK;MACrC,cAAc,MAAM,aAAa,KAAK;KACxC,EACyC,KAAK,CACqB,CAAC,CAClB;IACnD,MAAM,gBAAgB,yBAAyB,aAAa,OAAO;KAAE;KAAe;KAAY,CAAC;AAQjG,YAAQ,UAAU,IAAI,YAAY;AAClC,YAAQ,WAAW,IAAI,cAAc;AAOrC,iBAAa;AACX,mBAAc,SAAS;AACvB,iBAAY,SAAS;AACrB,aAAQ,WAAW,IAAI,KAAA,EAAU;AACjC,aAAQ,UAAU,IAAI,KAAA,EAAU;;MAGrC;GACF;EACF,CAAC;;;;;;;;;AAcJ,MAAa,yBAAyB,eAAe;CACnD,WAAW;EAAC;EAAgB;EAAwB;EAAiB;CACrE,aAAa;EAAC;EAAe;EAAoB;EAA0B;CAC3E,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAOP;EAMJ,MAAM,eAAe,mBACnB,MAAM,eAAe,KAAK,IAAI;GAC5B,cAAc;GACd,iBAAiB;GACjB,cAAc;GACd,iBAAiB;GACjB,cAAc;GACf,GACA,SAAS,MAAM,eAAe,IAAI,KAAK,CACzC;AACD,SAAO,kBAAkB;GACvB;GACA;GACA,QAAQ;IAAE,GAAG;IAAmB,OAAO;IAAc,GAAG;IAAQ;GACjE,CAAC;;CAEL,CAAC;;;;;;;;;AAUF,MAAa,yBAAyB,eAAe;CACnD,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa;EAAC;EAAe;EAAoB;EAA0B;CAC3E,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAMX,kBAAkB;EAChB;EACA;EACA,QAAQ;GAAE,GAAG;GAAmB,OAAO;GAAa,GAAG;GAAQ;EAChE,CAAC;CACL,CAAC"}
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"}

package/dist/default/playback/behaviors/dom/setup-mediasource.js CHANGED Viewed

@@ -1,8 +1,9 @@
-import { computed } from "../../../core/signals/primitives.js";
+import { computed, signal } 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 { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from "../../../media/dom/mse/mediasource-setup.js";
+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
@@ -38,27 +39,55 @@ import { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from "..
 * 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.
+*
 * Sole writer of `context.mediaSource`; other MSE behaviors
 * (`setupVideoBufferActors`, `setupAudioBufferActors`,
 * `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only
 * read.
 */
-function deriveState(presentation, mediaElement) {
+function deriveState(presentation, mediaElement, mediaSourceClosed) {
 	if (!mediaElement || !isResolvedPresentation(presentation)) return "preconditions-unmet";
+	if (mediaSourceClosed) return "preconditions-unmet";
 	return "mediasource-attached";
 }
-function setupMediaSourceSetup({ state, context }) {
-	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));
+function setupMediaSourceSetup({ state, context, config = {} }) {
+	const attach = config.attachMediaSource ?? attachMediaSource;
+	const loadingSuspended = state.loadingSuspended;
+	const mediaSourceClosed = signal(false);
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get(), mediaSourceClosed.get()));
 	return createMachineReactor({
 		initial: "preconditions-unmet",
 		monitor: () => derivedStateSignal.get(),
 		states: {
-			"preconditions-unmet": {},
+			"preconditions-unmet": { effects: () => {
+				if (mediaSourceClosed.get() && !loadingSuspended?.get()) mediaSourceClosed.set(false);
+			} },
 			"mediasource-attached": { entry: () => {
 				const mediaElement = context.mediaElement.get();
 				const controller = new AbortController();
 				const mediaSource = createMediaSource({ preferManaged: true });
-				const { detach } = attachMediaSource(mediaSource, mediaElement);
+				const { detach } = attach(mediaSource, mediaElement);
+				const teardown = () => {
+					mediaSourceClosed.set(true);
+					controller.abort();
+					context.mediaSource.set(void 0);
+					detach({ deferReset: true });
+				};
+				listen(mediaSource, "sourceclose", teardown, { signal: controller.signal });
 				const publishWhenOpen = async () => {
 					await waitForMediaSourceOpen(mediaSource, controller.signal);
 					if (controller.signal.aborted) return;
@@ -69,11 +98,7 @@ function setupMediaSourceSetup({ state, context }) {
 					context.mediaSource.set(mediaSource);
 				};
 				publishWhenOpen().catch((err) => console.error("[setupMediaSource] failed to publish MediaSource:", err));
-				return () => {
-					controller.abort();
-					detach();
-					context.mediaSource.set(void 0);
-				};
+				return teardown;
 			} }
 		}
 	});

package/dist/default/playback/behaviors/dom/setup-mediasource.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"setup-mediasource.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-mediasource.ts"],"sourcesContent":["/*\n Own the MediaSource lifecycle for the current source. When a resolved\n * presentation and a mediaElement are both in scope, creates a MediaSource,\n * attaches it to the element, waits for `'open'`, and publishes it on\n * `context.mediaSource`. On source change or behavior destroy, detaches the\n * MediaSource and clears the slot so the next source starts fresh.\n \n Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`):\n * state derivation gates on `mediaElement + isResolvedPresentation`. Riding the\n * resolver's resolved/unresolved lifecycle makes direct URL replacement\n * structural — `resolvePresentation` routes the presentation back through\n * unresolved on URL change, which drives this reactor through\n * `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old\n * MediaSource before the new one is built.\n \n The entry resolves preconditions in sequence before publishing:\n \n 1. Create + attach — `createMediaSource` + `attachMediaSource` run\n * synchronously on entry. The `detach` closure returned by\n * `attachMediaSource` is captured for state-exit cleanup, so the cleanup\n * is always bound to its setup even if the wait below is aborted.\n * 2. Wait for `'open'` — `waitForMediaSourceOpen` defers until the first\n * `sourceopen` event (or any readyState transition out of `'closed'`).\n * 3. Publish on `'open'` — re-check `readyState === 'open'` after the\n * await (covers `'ended'` / `'closed'` race) before writing to\n * `context.mediaSource`. Downstream `setupVideoBufferActors` /\n * `setupAudioBufferActors` call `addSourceBuffer` directly, which\n * throws on non-open, so publish-only-when-open is the load-bearing\n * contract.\n \n State-exit cleanup aborts the in-flight wait, detaches the MediaSource,\n * and clears `context.mediaSource`. Order: abort first (prevents a late\n * publish racing the slot clear), then detach, then clear.\n \n Sole writer of `context.mediaSource`; other MSE behaviors\n * (`setupVideoBufferActors`, `setupAudioBufferActors`,\n * `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only\n * read.\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 { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from '../../../media/dom/mse/mediasource-setup';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../../media/types';\n\n/\n State shape required for MediaSource setup.\n /\nexport interface MediaSourceState {\n presentation?: MaybeResolvedPresentation;\n}\n\n/\n Context shape for MediaSource setup.\n */\nexport interface MediaSourceContext {\n mediaElement?: HTMLMediaElement \| undefined;\n mediaSource?: MediaSource;\n}\n\ntype MediaSourceFsmState = 'preconditions-unmet' \| 'mediasource-attached';\n\nfunction deriveState(\n presentation: MaybeResolvedPresentation \| undefined,\n mediaElement: HTMLMediaElement \| undefined\n): MediaSourceFsmState {\n if (!mediaElement \|\| !isResolvedPresentation(presentation)) return 'preconditions-unmet';\n return 'mediasource-attached';\n}\n\nfunction setupMediaSourceSetup({\n state,\n context,\n}: {\n state: {\n presentation: ReadonlySignal<MediaSourceState['presentation']>;\n };\n context: {\n mediaElement: ReadonlySignal<MediaSourceContext['mediaElement']>;\n mediaSource: Signal<MediaSourceContext['mediaSource']>;\n };\n}): Reactor<MediaSourceFsmState \| 'destroying' \| 'destroyed'> {\n const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));\n\n return createMachineReactor<MediaSourceFsmState>({\n initial: 'preconditions-unmet',\n monitor: () => derivedStateSignal.get(),\n states: {\n 'preconditions-unmet': {},\n\n 'mediasource-attached': {\n // entry body is auto-untracked. deriveState handles source resets via\n // the resolver's resolved/unresolved transitions; this entry creates\n // and attaches the MediaSource, awaits `'open'`, publishes on\n // context, and binds detach + slot clear to state exit + destroy.\n entry: () => {\n const mediaElement = context.mediaElement.get()!;\n const controller = new AbortController();\n\n const mediaSource = createMediaSource({ preferManaged: true });\n // Sync attach: the returned `detach` closes over the element +\n // object-URL captured at this moment, so state-exit cleanup tears\n // down exactly this attachment regardless of how the wait below\n // resolves.\n const { detach } = attachMediaSource(mediaSource, mediaElement);\n\n const publishWhenOpen = async () => {\n await waitForMediaSourceOpen(mediaSource, controller.signal);\n if (controller.signal.aborted) return;\n // `waitForMediaSourceOpen` resolves on any readyState transition\n // out of `'closed'`; if we landed in `'ended'` / `'closed'`\n // instead of `'open'`, the attach window is gone and we leave\n // the slot unpublished. The session is dead within this source\n // either way — publishing wouldn't help because\n // `setupVideoBufferActors` / `setupAudioBufferActors` calls\n // `addSourceBuffer` which throws on non-open. The next\n // source-reset re-enters this state with a fresh MediaSource\n // and recovers. Warn so the case is at least diagnosable; in\n // practice it requires the MediaSource to close/end before its\n // very first `sourceopen`, which a freshly attached MS\n // shouldn't do.\n if (mediaSource.readyState !== 'open') {\n console.warn(\n `[setupMediaSource] MediaSource transitioned to '${mediaSource.readyState}' before first 'sourceopen' — slot left unpublished; recoverable on next source reset.`\n );\n return;\n }\n context.mediaSource.set(mediaSource);\n };\n\n publishWhenOpen().catch((err) => console.error('[setupMediaSource] failed to publish MediaSource:', err));\n\n return () => {\n // Order matters: abort the wait first so a late publish can't\n // race the slot clear; then detach to release the element; then\n // clear the slot so downstream behaviors see no MediaSource.\n controller.abort();\n detach();\n context.mediaSource.set(undefined);\n };\n },\n },\n },\n });\n}\n\nexport const setupMediaSource = defineBehavior({\n stateKeys: ['presentation'],\n contextKeys: ['mediaElement', 'mediaSource'],\n setup: setupMediaSourceSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAS,YACP,cACA,cACqB;AACrB,KAAI,CAAC,gBAAgB,CAAC,uBAAuB,aAAa,CAAE,QAAO;AACnE,QAAO;;AAGT,SAAS,sBAAsB,EAC7B,OACA,WAS4D;CAC5D,MAAM,qBAAqB,eAAe,YAAY,MAAM,aAAa,KAAK,EAAE,QAAQ,aAAa,KAAK,CAAC,CAAC;AAE5G,QAAO,qBAA0C;EAC/C,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,wBAAwB,EAKtB,aAAa;IACX,MAAM,eAAe,QAAQ,aAAa,KAAK;IAC/C,MAAM,aAAa,IAAI,iBAAiB;IAExC,MAAM,cAAc,kBAAkB,EAAE,eAAe,MAAM,CAAC;IAK9D,MAAM,EAAE,WAAW,kBAAkB,aAAa,aAAa;IAE/D,MAAM,kBAAkB,YAAY;AAClC,WAAM,uBAAuB,aAAa,WAAW,OAAO;AAC5D,SAAI,WAAW,OAAO,QAAS;AAa/B,SAAI,YAAY,eAAe,QAAQ;AACrC,cAAQ,KACN,mDAAmD,YAAY,WAAW,wFAC3E;AACD;;AAEF,aAAQ,YAAY,IAAI,YAAY;;AAGtC,qBAAiB,CAAC,OAAO,QAAQ,QAAQ,MAAM,qDAAqD,IAAI,CAAC;AAEzG,iBAAa;AAIX,gBAAW,OAAO;AAClB,aAAQ;AACR,aAAQ,YAAY,IAAI,KAAA,EAAU;;MAGvC;GACF;EACF,CAAC;;AAGJ,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,eAAe;CAC3B,aAAa,CAAC,gBAAgB,cAAc;CAC5C,OAAO;CACR,CAAC"}
1	+ {"version":3,"file":"setup-mediasource.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-mediasource.ts"],"sourcesContent":["/*\n Own the MediaSource lifecycle for the current source. When a resolved\n * presentation and a mediaElement are both in scope, creates a MediaSource,\n * attaches it to the element, waits for `'open'`, and publishes it on\n * `context.mediaSource`. On source change or behavior destroy, detaches the\n * MediaSource and clears the slot so the next source starts fresh.\n \n Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`):\n * state derivation gates on `mediaElement + isResolvedPresentation`. Riding the\n * resolver's resolved/unresolved lifecycle makes direct URL replacement\n * structural — `resolvePresentation` routes the presentation back through\n * unresolved on URL change, which drives this reactor through\n * `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old\n * MediaSource before the new one is built.\n \n The entry resolves preconditions in sequence before publishing:\n \n 1. Create + attach — `createMediaSource` + `attachMediaSource` run\n * synchronously on entry. The `detach` closure returned by\n * `attachMediaSource` is captured for state-exit cleanup, so the cleanup\n * is always bound to its setup even if the wait below is aborted.\n * 2. Wait for `'open'` — `waitForMediaSourceOpen` defers until the first\n * `sourceopen` event (or any readyState transition out of `'closed'`).\n * 3. Publish on `'open'` — re-check `readyState === 'open'` after the\n * await (covers `'ended'` / `'closed'` race) before writing to\n * `context.mediaSource`. Downstream `setupVideoBufferActors` /\n * `setupAudioBufferActors` call `addSourceBuffer` directly, which\n * throws on non-open, so publish-only-when-open is the load-bearing\n * contract.\n \n State-exit cleanup aborts the in-flight wait, detaches the MediaSource,\n * and clears `context.mediaSource`. Order: abort first (prevents a late\n * publish racing the slot clear), then detach, then clear.\n \n # Sourceclose recovery\n \n The behavior owns one unclosed MediaSource per source identity. The UA can\n * close the attached MediaSource out from under the engine (Safari on an\n * AirPlay handoff — see `setupAirPlay` — or a ManagedMediaSource evicted\n * under memory pressure), and a closed MediaSource can never reopen. The\n * `sourceclose` listener tears the attachment down synchronously; every\n * teardown records a local close-fact, which holds the machine out until\n * the fact is consumed — then the re-derive comes back in with a fresh\n * MediaSource for the same source. Cause-agnostic. Consumption honors an\n * observed `loadingSuspended` (attaching runs `element.load()` — new loading\n * work, e.g. resource selection under an active AirPlay receiver), and\n * happens only while the machine is out, so a suspension can never tear\n * down an existing attachment.\n \n Sole writer of `context.mediaSource`; other MSE behaviors\n * (`setupVideoBufferActors`, `setupAudioBufferActors`,\n * `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only\n * read.\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, signal } from '../../../core/signals/primitives';\nimport { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from '../../../media/dom/mse/mediasource-setup';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../../media/types';\n\n/\n State shape required for MediaSource setup.\n /\nexport interface MediaSourceState {\n presentation?: MaybeResolvedPresentation;\n}\n\n/\n Context shape for MediaSource setup.\n /\nexport interface MediaSourceContext {\n mediaElement?: HTMLMediaElement \| undefined;\n mediaSource?: MediaSource;\n}\n\n/\n Config for MediaSource setup.\n /\nexport interface MediaSourceSetupConfig {\n /\n Attach strategy — a composition-supplied implementation. Defaults to\n * `attachMediaSource` (object URL on the `src` attribute). Compositions\n * that pair MSE with sibling `<source>` alternatives wire\n * `attachMediaSourceAsSourceElement` (e.g. the HLS engine, for\n * `setupAirPlay`'s native fallback source).\n */\n attachMediaSource?: typeof attachMediaSource;\n}\n\ntype MediaSourceFsmState = 'preconditions-unmet' \| 'mediasource-attached';\n\nfunction deriveState(\n presentation: MaybeResolvedPresentation \| undefined,\n mediaElement: HTMLMediaElement \| undefined,\n mediaSourceClosed: boolean\n): MediaSourceFsmState {\n if (!mediaElement \|\| !isResolvedPresentation(presentation)) return 'preconditions-unmet';\n // The current attachment was torn down (typically a UA-fired\n // `sourceclose`). The fact stands until the `'preconditions-unmet'`\n // effects consume it (see below); the reset then re-derives into a fresh\n // attach for the same source.\n if (mediaSourceClosed) return 'preconditions-unmet';\n return 'mediasource-attached';\n}\n\nfunction setupMediaSourceSetup({\n state,\n context,\n config = {},\n}: {\n state: {\n presentation: ReadonlySignal<MediaSourceState['presentation']>;\n };\n context: {\n mediaElement: ReadonlySignal<MediaSourceContext['mediaElement']>;\n mediaSource: Signal<MediaSourceContext['mediaSource']>;\n };\n config?: MediaSourceSetupConfig;\n}): Reactor<MediaSourceFsmState \| 'destroying' \| 'destroyed'> {\n const attach = config.attachMediaSource ?? attachMediaSource;\n // `loadingSuspended` is observed, never declared: the slot exists only in\n // compositions where a feature behavior (e.g. `setupAirPlay`) declares and\n // writes it, so it lives behind a cast rather than in the typed param\n // above — an optional param key would force declaring it in `stateKeys`,\n // which is what materializes a slot. Shape redefined locally (canonical:\n // `SegmentLoadingState['loadingSuspended']`) to avoid a load-segments\n // module dependency.\n const loadingSuspended = (state as { loadingSuspended?: ReadonlySignal<boolean \| undefined> }).loadingSuspended;\n\n // Close-fact for the currently-owned MediaSource, flipped by the\n // entry's shared teardown. Consumed in `'preconditions-unmet'`.\n const mediaSourceClosed = signal(false);\n\n const derivedStateSignal = computed(() =>\n deriveState(state.presentation.get(), context.mediaElement.get(), mediaSourceClosed.get())\n );\n\n return createMachineReactor<MediaSourceFsmState>({\n initial: 'preconditions-unmet',\n monitor: () => derivedStateSignal.get(),\n states: {\n 'preconditions-unmet': {\n // Consume a recorded close once new loading work may initiate — the\n // reset re-derives into `'mediasource-attached'`, rebuilding a fresh\n // MediaSource for the same source. While an observed\n // `loadingSuspended` holds, the fact stands and the rebuild waits:\n // attaching runs `element.load()`, which is exactly the loading work\n // the suspension forbids. Consuming only from this state means a\n // suspension can never tear down an existing attachment — there is\n // no code path from `loadingSuspended` to an exit.\n effects: () => {\n // `mediaSourceClosed` is tracked, not peeked: a new state's effects\n // can run BEFORE the old state's exit cleanup (effects run in\n // states-declaration order), so a teardown's fact-write can land\n // after this effect's entry run — tracking re-fires the consume.\n // Not suspended = slot absent (no writer composed) or value falsy.\n if (mediaSourceClosed.get() && !loadingSuspended?.get()) mediaSourceClosed.set(false);\n },\n },\n\n 'mediasource-attached': {\n // entry body is auto-untracked. deriveState handles source resets via\n // the resolver's resolved/unresolved transitions; this entry creates\n // and attaches the MediaSource, awaits `'open'`, publishes on\n // context, and binds detach + slot clear to state exit + destroy.\n entry: () => {\n const mediaElement = context.mediaElement.get()!;\n const controller = new AbortController();\n\n const mediaSource = createMediaSource({ preferManaged: true });\n // Sync attach: the returned `detach` closes over the element +\n // object-URL captured at this moment, so state-exit cleanup tears\n // down exactly this attachment regardless of how the wait below\n // resolves.\n const { detach } = attach(mediaSource, mediaElement);\n\n // One complete teardown, shared by both triggers (the sourceclose\n // listener below and the state-exit cleanup) — whichever fires\n // first does the work; a re-run is harmless. Order matters:\n //\n // 1. Abort first — kills the open-wait and the listener, so a late\n // publish can't race the slot clear.\n // 2. Clear the slot, which stops the downstream MSE pipeline and\n // dirties the effects of behaviors owning sibling `<source>`\n // children (`setupAirPlay`'s native-HLS fallback), queueing their\n // removal pass. Kept ahead of the detach so that queueing is\n // explicit: the `mediaSourceClosed` write above happens to queue\n // the same pass today, but depending on it would couple this to\n // an unrelated write.\n // 3. Detach with `deferReset`, which queues detach's `load()` reset\n // behind that pass. A synchronous reset would run resource\n // selection while the fallback is still in the DOM and commit the\n // element to the outgoing manifest — starting native HLS playback\n // of the source being torn down. Removing our own `<source>`\n // doesn't re-run selection on its own, so nothing starts in the\n // gap. The ownership guard re-checks at fire time, so a re-attach\n // landing in between suppresses the reset.\n const teardown = () => {\n mediaSourceClosed.set(true);\n controller.abort();\n context.mediaSource.set(undefined);\n detach({ deferReset: true });\n };\n\n // Sourceclose recovery: the UA closing this MediaSource (AirPlay\n // handoff, MMS eviction) tears the attachment down synchronously —\n // detach skips\n // its `load()` reset for a closed MediaSource (see\n // `attachMediaSource`), leaving the element as the session or\n // eviction left it.\n listen(mediaSource, 'sourceclose', teardown, { signal: controller.signal });\n\n const publishWhenOpen = async () => {\n await waitForMediaSourceOpen(mediaSource, controller.signal);\n if (controller.signal.aborted) return;\n // `waitForMediaSourceOpen` resolves on any readyState transition\n // out of `'closed'`; if we landed in `'ended'` / `'closed'`\n // instead of `'open'`, the attach window is gone and we leave\n // the slot unpublished. The session is dead within this source\n // either way — publishing wouldn't help because\n // `setupVideoBufferActors` / `setupAudioBufferActors` calls\n // `addSourceBuffer` which throws on non-open. The next\n // source-reset re-enters this state with a fresh MediaSource\n // and recovers. Warn so the case is at least diagnosable; in\n // practice it requires the MediaSource to close/end before its\n // very first `sourceopen`, which a freshly attached MS\n // shouldn't do.\n if (mediaSource.readyState !== 'open') {\n console.warn(\n `[setupMediaSource] MediaSource transitioned to '${mediaSource.readyState}' before first 'sourceopen' — slot left unpublished; recoverable on next source reset.`\n );\n return;\n }\n context.mediaSource.set(mediaSource);\n };\n\n publishWhenOpen().catch((err) => console.error('[setupMediaSource] failed to publish MediaSource:', err));\n\n // State-exit cleanup — fires on source unload, element detach, or\n // behavior destroy; a harmless re-run after a `sourceclose`\n // already tore down.\n return teardown;\n },\n },\n },\n });\n}\n\nexport const setupMediaSource = defineBehavior({\n stateKeys: ['presentation'],\n contextKeys: ['mediaElement', 'mediaSource'],\n setup: setupMediaSourceSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6FA,SAAS,YACP,cACA,cACA,mBACqB;CACrB,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,YAAY,GAAG,OAAO;CAKnE,IAAI,mBAAmB,OAAO;CAC9B,OAAO;AACT;AAEA,SAAS,sBAAsB,EAC7B,OACA,SACA,SAAS,CAAC,KAUkD;CAC5D,MAAM,SAAS,OAAO,qBAAqB;CAQ3C,MAAM,mBAAoB,MAAqE;CAI/F,MAAM,oBAAoB,OAAO,KAAK;CAEtC,MAAM,qBAAqB,eACzB,YAAY,MAAM,aAAa,IAAI,GAAG,QAAQ,aAAa,IAAI,GAAG,kBAAkB,IAAI,CAAC,CAC3F;CAEA,OAAO,qBAA0C;EAC/C,SAAS;EACT,eAAe,mBAAmB,IAAI;EACtC,QAAQ;GACN,uBAAuB,EASrB,eAAe;IAMb,IAAI,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,IAAI,GAAG,kBAAkB,IAAI,KAAK;GACtF,EACF;GAEA,wBAAwB,EAKtB,aAAa;IACX,MAAM,eAAe,QAAQ,aAAa,IAAI;IAC9C,MAAM,aAAa,IAAI,gBAAgB;IAEvC,MAAM,cAAc,kBAAkB,EAAE,eAAe,KAAK,CAAC;IAK7D,MAAM,EAAE,WAAW,OAAO,aAAa,YAAY;IAuBnD,MAAM,iBAAiB;KACrB,kBAAkB,IAAI,IAAI;KAC1B,WAAW,MAAM;KACjB,QAAQ,YAAY,IAAI,KAAA,CAAS;KACjC,OAAO,EAAE,YAAY,KAAK,CAAC;IAC7B;IAQA,OAAO,aAAa,eAAe,UAAU,EAAE,QAAQ,WAAW,OAAO,CAAC;IAE1E,MAAM,kBAAkB,YAAY;KAClC,MAAM,uBAAuB,aAAa,WAAW,MAAM;KAC3D,IAAI,WAAW,OAAO,SAAS;KAa/B,IAAI,YAAY,eAAe,QAAQ;MACrC,QAAQ,KACN,mDAAmD,YAAY,WAAW,uFAC5E;MACA;KACF;KACA,QAAQ,YAAY,IAAI,WAAW;IACrC;IAEA,gBAAgB,CAAC,CAAC,OAAO,QAAQ,QAAQ,MAAM,qDAAqD,GAAG,CAAC;IAKxG,OAAO;GACT,EACF;EACF;CACF,CAAC;AACH;AAEA,MAAa,mBAAmB,eAAe;CAC7C,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,gBAAgB,aAAa;CAC3C,OAAO;AACT,CAAC"}

package/dist/default/playback/behaviors/dom/setup-text-track-actors.js CHANGED Viewed

@@ -1,34 +1,20 @@
-import { defineBehavior } from "../../../core/composition/create-composition.js";
 import { effect } from "../../../core/signals/effect.js";
 import { createTextTracksActor } from "../../actors/dom/text-tracks.js";
 import { createTextTrackSegmentLoaderActor } from "../../actors/text-track-segment-loader.js";
 //#region src/playback/behaviors/dom/setup-text-track-actors.ts
-/**
-* **Own the TextTracks actor pair for the current `mediaElement`.** When a
-* `mediaElement` is in scope, creates the `TextTracksActor` (bound to the
-* element's `textTracks`) and the `TextTrackSegmentLoaderActor` (bound to
-* that actor + the injected cue resolver), and publishes both on
-* `context`. On element identity change or behavior destroy, destroys both
-* actors and clears the slots.
-*
-* Single-resource synchronous create/destroy driven by one signal — the
-* simple-effect form is the right shape (per `behaviors.md` → "Where both
-* shapes are legitimate": criterion 4b applies; sole writer of
-* `textTracksActor` / `textTrackSegmentLoaderActor`, the effect's cleanup
-* return handles destroy + slot clear structurally).
-*
-* Pairs with the `loadTextTrackSegments` behavior (a per-type variant of
-* `setupSegmentLoading` in `load-segments.ts`), which only reads
-* `textTrackSegmentLoaderActor`. The cue resolver is injected via
-* `config` so this behavior owns the DOM-bound part of the text-track
-* pipeline.
-*/
-function setupTextTrackActorsSetup({ context, config }) {
+function setupTextTrackActorsSetup({ state, context, config }) {
 	return effect(() => {
 		const mediaElement = context.mediaElement.get();
 		if (!mediaElement) return;
 		const textTracksActor = createTextTracksActor(mediaElement);
-		const textTrackSegmentLoaderActor = createTextTrackSegmentLoaderActor(textTracksActor, config.resolveTextTrackSegment, { forwardBuffer: config.forwardBuffer });
+		const textTrackSegmentLoaderActor = createTextTrackSegmentLoaderActor(textTracksActor, config.resolveTextTrackSegment, {
+			forwardBuffer: config.forwardBuffer,
+			messagePipelines: config.textMessagePipelines
+		}, {
+			state,
+			context,
+			config
+		});
 		context.textTracksActor.set(textTracksActor);
 		context.textTrackSegmentLoaderActor.set(textTrackSegmentLoaderActor);
 		return () => {
@@ -39,7 +25,7 @@ function setupTextTrackActorsSetup({ context, config }) {
 		};
 	});
 }
-const setupTextTrackActors = defineBehavior({
+const setupTextTrackActors = {
 	stateKeys: [],
 	contextKeys: [
 		"mediaElement",
@@ -47,7 +33,7 @@ const setupTextTrackActors = defineBehavior({
 		"textTrackSegmentLoaderActor"
 	],
 	setup: setupTextTrackActorsSetup
-});
+};
 //#endregion
 export { setupTextTrackActors };