@videojs/spf 10.0.0-beta.9 → 10.0.0-rc.2

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

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

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

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

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

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

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

@@ -0,0 +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 presentation and a mediaElement are both in\n * scope, creates a MediaSource, attaches it to the element, waits for `'open'`, and publishes it on\n * `context.mediaSource`. On source change or behavior destroy, detaches the MediaSource and clears the slot so the next\n * source starts fresh.\n *\n * Single-positive-state reactor (`'preconditions-unmet'` ↔ `'mediasource-attached'`): state derivation gates on\n * `mediaElement + isResolvedPresentation`. Riding the resolver's resolved/unresolved lifecycle makes direct URL\n * replacement structural — `resolvePresentation` routes the presentation back through unresolved on URL change, which\n * drives this reactor through `'preconditions-unmet'` so the entry's state-exit cleanup detaches the old MediaSource\n * before the new one is built.\n *\n * The entry resolves preconditions in sequence before publishing:\n *\n * 1. **Create + attach** — `createMediaSource` + `attachMediaSource` run synchronously on entry. The `detach` closure\n *    returned by `attachMediaSource` is captured for state-exit cleanup, so the cleanup is always bound to its setup\n *    even if the wait below is aborted.\n * 2. **Wait for `'open'`** — `waitForMediaSourceOpen` defers until the first `sourceopen` event (or any readyState\n *    transition out of `'closed'`).\n * 3. **Publish on `'open'`** — re-check `readyState === 'open'` after the await (covers `'ended'` / `'closed'` race)\n *    before writing to `context.mediaSource`. Downstream `setupVideoBufferActors` / `setupAudioBufferActors` call\n *    `addSourceBuffer` directly, which throws on non-open, so publish-only-when-open is the load-bearing contract.\n *\n * State-exit cleanup aborts the in-flight wait, detaches the MediaSource, and clears `context.mediaSource`. Order:\n * abort first (prevents a late 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 close the attached MediaSource out\n * from under the engine (Safari on an AirPlay handoff — see `setupAirPlay` — or a ManagedMediaSource evicted under\n * memory pressure), and a closed MediaSource can never reopen. The `sourceclose` listener tears the attachment down\n * synchronously; every teardown records a local close-fact, which holds the machine out until the fact is consumed —\n * then the re-derive comes back in with a fresh MediaSource for the _same_ source. Cause-agnostic. Consumption honors\n * an observed `loadingSuspended` (attaching runs `element.load()` — new loading work, e.g. resource selection under an\n * active AirPlay receiver), and happens only while the machine is out, so a suspension can never tear down an existing\n * attachment.\n *\n * Sole writer of `context.mediaSource`; other MSE behaviors (`setupVideoBufferActors`, `setupAudioBufferActors`,\n * `updateMediaSourceDuration`, `endOfStream`, `loadVideoSegments`) only read.\n */\nimport { listen } from '@videojs/utils/dom';\n\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal, signal } from '../../../core/signals/primitives';\nimport { attachMediaSource, createMediaSource, waitForMediaSourceOpen } from '../../../media/dom/mse/mediasource-setup';\nimport { isResolvedPresentation, type MaybeResolvedPresentation } from '../../../media/types';\n\n/** State shape required for MediaSource setup. */\nexport interface MediaSourceState {\n  presentation?: MaybeResolvedPresentation;\n}\n\n/** Context shape for MediaSource setup. */\nexport interface MediaSourceContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  mediaSource?: MediaSource;\n}\n\n/** Config for MediaSource setup. */\nexport interface MediaSourceSetupConfig {\n  /**\n   * Attach strategy — a composition-supplied implementation. Defaults to `attachMediaSource` (object URL on the `src`\n   * attribute). Compositions that pair MSE with sibling `<source>` alternatives wire `attachMediaSourceAsSourceElement`\n   * (e.g. the HLS engine, for `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\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\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\n            if (controller.signal.aborted) return;\n\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\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,SAAS,YACP,cACA,cACA,mBACqB;CACrB,IAAI,CAAC,gBAAgB,CAAC,uBAAuB,YAAY,GAAG,OAAO;CAMnE,IAAI,mBAAmB,OAAO;CAE9B,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;KAE3D,IAAI,WAAW,OAAO,SAAS;KAc/B,IAAI,YAAY,eAAe,QAAQ;MACrC,QAAQ,KACN,mDAAmD,YAAY,WAAW,uFAC5E;MACA;KACF;KAEA,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/dev/playback/behaviors/dom/setup-text-track-actors.d.ts

@@ -0,0 +1,28 @@
+import { ReadonlySignal, Signal } from "../../../core/signals/primitives.js";
+import { Behavior } from "../../../core/composition/create-composition.js";
+import { TextMessagePipelines, TextTrackSegmentResolver } from "../../primitives/text-segment-load-pipeline.js";
+import { TextTracksActor } from "../../actors/text-tracks.js";
+import { TextTrackSegmentLoaderActor, TextTrackSegmentLoaderActorConfig } from "../../actors/text-track-segment-loader.js";
+//#region src/playback/behaviors/dom/setup-text-track-actors.d.ts
+interface TextTrackActorsContext {
+  mediaElement?: HTMLMediaElement | undefined;
+  textTracksActor?: TextTracksActor<VTTCue> | undefined;
+  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;
+}
+interface TextTrackActorsConfig extends Pick<TextTrackSegmentLoaderActorConfig<VTTCue>, 'forwardBuffer'> {
+  resolveTextTrackSegment: TextTrackSegmentResolver<VTTCue>;
+  /**
+   * Ordered text step pipeline, mapped to the loader's `messagePipelines`. Named with the `text` domain prefix to
+   * mirror the v/a `video`/`audioMessagePipelines` composition-config slots. Defaults (in the loader) to `resolveCues →
+   * dispatchCues`.
+   */
+  textMessagePipelines?: TextMessagePipelines<VTTCue>;
+}
+declare const setupTextTrackActors: Behavior<Record<never, never>, {
+  mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;
+  textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;
+  textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;
+}, TextTrackActorsConfig>;
+//#endregion
+export { TextTrackActorsConfig, TextTrackActorsContext, setupTextTrackActors };
+//# sourceMappingURL=setup-text-track-actors.d.ts.map

package/dist/dev/playback/behaviors/dom/setup-text-track-actors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-text-track-actors.d.ts","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-text-track-actors.ts"],"mappings":";;;;;;UA0BiB;EACf,eAAe;EACf,kBAAkB,gBAAgB;EAClC,8BAA8B;;UAGf,8BAA8B,KAAK,kCAAkC;EACpF,yBAAyB,yBAAyB;;;;;;EAMlD,uBAAuB,qBAAqB;;cA+CjC,sBAAsB,SACjC;EAEE,cAAc,eAAe;EAC7B,iBAAiB,OAAO;EACxB,6BAA6B,OAAO;GAEtC"}

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

@@ -0,0 +1,40 @@
+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
+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,
+			messagePipelines: config.textMessagePipelines
+		}, {
+			state,
+			context,
+			config
+		});
+		context.textTracksActor.set(textTracksActor);
+		context.textTrackSegmentLoaderActor.set(textTrackSegmentLoaderActor);
+		return () => {
+			textTracksActor.destroy();
+			textTrackSegmentLoaderActor.destroy();
+			context.textTracksActor.set(void 0);
+			context.textTrackSegmentLoaderActor.set(void 0);
+		};
+	});
+}
+const setupTextTrackActors = {
+	stateKeys: [],
+	contextKeys: [
+		"mediaElement",
+		"textTracksActor",
+		"textTrackSegmentLoaderActor"
+	],
+	setup: setupTextTrackActorsSetup
+};
+//#endregion
+export { setupTextTrackActors };
+
+//# sourceMappingURL=setup-text-track-actors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup-text-track-actors.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/setup-text-track-actors.ts"],"sourcesContent":["/**\n * **Own the TextTracks actor pair for the current `mediaElement`.** When a `mediaElement` is in scope, creates the\n * `TextTracksActor` (bound to the element's `textTracks`) and the `TextTrackSegmentLoaderActor` (bound to that actor +\n * the injected cue resolver), and publishes both on `context`. On element identity change or behavior destroy, destroys\n * both actors and clears the slots.\n *\n * Single-resource synchronous create/destroy driven by one signal — the simple-effect form is the right shape (per\n * `behaviors.md` → \"Where both shapes are legitimate\": criterion 4b applies; sole writer of `textTracksActor` /\n * `textTrackSegmentLoaderActor`, the effect's cleanup return handles destroy + slot clear structurally).\n *\n * Pairs with the `loadTextTrackSegments` behavior (a per-type variant of `setupSegmentLoading` in `load-segments.ts`),\n * which only reads `textTrackSegmentLoaderActor`. The cue resolver is injected via `config` so this behavior owns the\n * DOM-bound part of the text-track pipeline.\n */\nimport type { AnySlotMap, Behavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../../core/signals/primitives';\nimport { createTextTracksActor } from '../../actors/dom/text-tracks';\nimport {\n  createTextTrackSegmentLoaderActor,\n  type TextTrackSegmentLoaderActor,\n  type TextTrackSegmentLoaderActorConfig,\n} from '../../actors/text-track-segment-loader';\nimport type { TextTracksActor } from '../../actors/text-tracks';\nimport type { TextMessagePipelines, TextTrackSegmentResolver } from '../../primitives/text-segment-load-pipeline';\n\nexport interface TextTrackActorsContext {\n  mediaElement?: HTMLMediaElement | undefined;\n  textTracksActor?: TextTracksActor<VTTCue> | undefined;\n  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;\n}\n\nexport interface TextTrackActorsConfig extends Pick<TextTrackSegmentLoaderActorConfig<VTTCue>, 'forwardBuffer'> {\n  resolveTextTrackSegment: TextTrackSegmentResolver<VTTCue>;\n  /**\n   * Ordered text step pipeline, mapped to the loader's `messagePipelines`. Named with the `text` domain prefix to\n   * mirror the v/a `video`/`audioMessagePipelines` composition-config slots. Defaults (in the loader) to `resolveCues →\n   * dispatchCues`.\n   */\n  textMessagePipelines?: TextMessagePipelines<VTTCue>;\n}\n\nfunction setupTextTrackActorsSetup({\n  state,\n  context,\n  config,\n}: {\n  // Forwarded opaquely into the loader's steps (relocation reads composition state);\n  // this behavior owns no state of its own (stateKeys: []).\n  state: AnySlotMap;\n  context: {\n    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;\n    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;\n    textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;\n  };\n  config: TextTrackActorsConfig;\n}): () => void {\n  return effect(() => {\n    const mediaElement = context.mediaElement.get();\n    if (!mediaElement) return;\n\n    const textTracksActor = createTextTracksActor(mediaElement);\n    const textTrackSegmentLoaderActor = createTextTrackSegmentLoaderActor(\n      textTracksActor,\n      config.resolveTextTrackSegment,\n      { forwardBuffer: config.forwardBuffer, messagePipelines: config.textMessagePipelines },\n      // Composition deps forwarded into each step (relocation reads the primary A/V origin).\n      { state, context, config }\n    );\n\n    context.textTracksActor.set(textTracksActor);\n    context.textTrackSegmentLoaderActor.set(textTrackSegmentLoaderActor);\n\n    return () => {\n      textTracksActor.destroy();\n      textTrackSegmentLoaderActor.destroy();\n      context.textTracksActor.set(undefined);\n      context.textTrackSegmentLoaderActor.set(undefined);\n    };\n  });\n}\n\n// Manual `Behavior` literal (like `end-of-stream`): no state of its own\n// (`stateKeys: []`), but the setup forwards the composition `state` to the resolver\n// opaquely. A literal (not `defineBehavior`) so `stateKeys: []` can coexist with a\n// setup that reads `state`.\nexport const setupTextTrackActors: Behavior<\n  Record<never, never>,\n  {\n    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;\n    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;\n    textTrackSegmentLoaderActor: Signal<TextTrackActorsContext['textTrackSegmentLoaderActor']>;\n  },\n  TextTrackActorsConfig\n> = {\n  stateKeys: [],\n  contextKeys: ['mediaElement', 'textTracksActor', 'textTrackSegmentLoaderActor'],\n  setup: setupTextTrackActorsSetup,\n};\n"],"mappings":";;;;AA0CA,SAAS,0BAA0B,EACjC,OACA,SACA,UAWa;CACb,OAAO,aAAa;EAClB,MAAM,eAAe,QAAQ,aAAa,IAAI;EAC9C,IAAI,CAAC,cAAc;EAEnB,MAAM,kBAAkB,sBAAsB,YAAY;EAC1D,MAAM,8BAA8B,kCAClC,iBACA,OAAO,yBACP;GAAE,eAAe,OAAO;GAAe,kBAAkB,OAAO;EAAqB,GAErF;GAAE;GAAO;GAAS;EAAO,CAC3B;EAEA,QAAQ,gBAAgB,IAAI,eAAe;EAC3C,QAAQ,4BAA4B,IAAI,2BAA2B;EAEnE,aAAa;GACX,gBAAgB,QAAQ;GACxB,4BAA4B,QAAQ;GACpC,QAAQ,gBAAgB,IAAI,KAAA,CAAS;GACrC,QAAQ,4BAA4B,IAAI,KAAA,CAAS;EACnD;CACF,CAAC;AACH;AAMA,MAAa,uBAQT;CACF,WAAW,CAAC;CACZ,aAAa;EAAC;EAAgB;EAAmB;CAA6B;CAC9E,OAAO;AACT"}

package/dist/dev/playback/behaviors/dom/sync-live-seekable-range.js

@@ -0,0 +1,25 @@
+import { effect } from "../../../core/signals/effect.js";
+import { liveWindowFromState } from "../../primitives/live-window.js";
+//#region src/playback/behaviors/dom/sync-live-seekable-range.ts
+function syncLiveSeekableRangeSetup({ state, context }) {
+	return effect(() => {
+		const mediaSource = context.mediaSource.get();
+		const liveWindow = liveWindowFromState(state);
+		if (!mediaSource || !liveWindow) return;
+		mediaSource.setLiveSeekableRange(liveWindow.start, liveWindow.end);
+	});
+}
+/**
+* Manual `Behavior<>` literal (like `seekToLiveEdge`): declares only `presentation` in stateKeys while reading
+* `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the switch* behaviors), so it composes
+* without a stateKeys/type conflict.
+*/
+const syncLiveSeekableRange = {
+	stateKeys: ["presentation"],
+	contextKeys: ["mediaSource"],
+	setup: syncLiveSeekableRangeSetup
+};
+//#endregion
+export { syncLiveSeekableRange };
+
+//# sourceMappingURL=sync-live-seekable-range.js.map

package/dist/dev/playback/behaviors/dom/sync-live-seekable-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-live-seekable-range.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/sync-live-seekable-range.ts"],"sourcesContent":["/**\n * Mirror the live window into the MediaSource's seekable range. On every window update — **including while paused**\n * (the seekable range must stay current as the window slides, regardless of play state) — declare\n * `setLiveSeekableRange(start, end)` so the browser's `HTMLMediaElement.seekable` reflects the live window (without it,\n * `seekable` is empty under `duration === Infinity`).\n *\n * The live window comes from `liveWindowFromState` (the shared derivation — the intersection over the selected A/V\n * tracks' windows); inert when it returns `null` (VoD / ended live). Composed _before_ `seekToLiveEdge` so the range is\n * declared before that behavior seeks the playhead into it (a seek outside `seekable` is clamped).\n *\n * Duration is owned solely by `updateMediaSourceDuration`; this behavior only declares the seekable range\n * (`setLiveSeekableRange` requires only `readyState === 'open'` per the W3C MSE spec, not a set `duration`).\n *\n * No `clearLiveSeekableRange()` on termination, by design: the MSE spec consults the live seekable range _only_ while\n * `duration === Infinity`. When a live stream ends, `endOfStream()` sets a finite duration and the UA derives\n * `seekable` from buffered + duration, ignoring the live range — so clearing is unnecessary. Clearing on the\n * `ENDLIST`→finite-`Track.duration` transition (when the window goes `null`) would also be premature: `duration` is\n * still `Infinity` until `endOfStream`, so clearing would shrink `seekable` to buffered-only while the stream is still\n * effectively live.\n */\nimport type { Behavior } from '../../../core/composition/create-composition';\nimport { effect } from '../../../core/signals/effect';\nimport type { ReadonlySignal } from '../../../core/signals/primitives';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { liveWindowFromState } from '../../primitives/live-window';\n\nexport interface SyncLiveSeekableRangeState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\nexport interface SyncLiveSeekableRangeContext {\n  mediaSource?: MediaSource;\n}\n\nfunction syncLiveSeekableRangeSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<SyncLiveSeekableRangeState['presentation']>;\n    selectedVideoTrackId?: ReadonlySignal<SyncLiveSeekableRangeState['selectedVideoTrackId']>;\n    selectedAudioTrackId?: ReadonlySignal<SyncLiveSeekableRangeState['selectedAudioTrackId']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<SyncLiveSeekableRangeContext['mediaSource']>;\n  };\n}): () => void {\n  return effect(() => {\n    const mediaSource = context.mediaSource.get();\n    const liveWindow = liveWindowFromState(state);\n    if (!mediaSource || !liveWindow) return;\n\n    // Re-declared as the window slides so seekable tracks the live window\n    // (the full DVR range remains seekable; seek-to-live-edge starts near the edge).\n    // No readyState check, no try/catch: `setLiveSeekableRange` throws only on a\n    // non-'open' readyState or an invalid range, and neither can occur here —\n    // `setupMediaSource` publishes `context.mediaSource` only while open, and a\n    // non-null live window means the timeline-bearing track is still `Infinity`\n    // (so `endOfStream` hasn't ended the MS); `liveWindowFromState` guarantees\n    // 0 ≤ start < end (the reference type's window starts ≥ 0, and the A/V\n    // intersection `max`-clamps a non-reference track's negative early start).\n    mediaSource.setLiveSeekableRange(liveWindow.start, liveWindow.end);\n  });\n}\n\n/**\n * Manual `Behavior<>` literal (like `seekToLiveEdge`): declares only `presentation` in stateKeys while reading\n * `selectedVideoTrackId` / `selectedAudioTrackId` defensively (contributed by the switch* behaviors), so it composes\n * without a stateKeys/type conflict.\n */\nexport const syncLiveSeekableRange: Behavior<\n  { presentation: ReadonlySignal<SyncLiveSeekableRangeState['presentation']> },\n  { mediaSource: ReadonlySignal<SyncLiveSeekableRangeContext['mediaSource']> },\n  object\n> = {\n  stateKeys: ['presentation'],\n  contextKeys: ['mediaSource'],\n  setup: syncLiveSeekableRangeSetup,\n};\n"],"mappings":";;;AAoCA,SAAS,2BAA2B,EAClC,OACA,WAUa;CACb,OAAO,aAAa;EAClB,MAAM,cAAc,QAAQ,YAAY,IAAI;EAC5C,MAAM,aAAa,oBAAoB,KAAK;EAC5C,IAAI,CAAC,eAAe,CAAC,YAAY;EAWjC,YAAY,qBAAqB,WAAW,OAAO,WAAW,GAAG;CACnE,CAAC;AACH;;;;;;AAOA,MAAa,wBAIT;CACF,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT"}

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

@@ -0,0 +1,109 @@
+import { computed, peek } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { getTracksByType } from "../../../media/utils/tracks.js";
+import { syncTextTrackModes } from "../../../media/dom/text/text-track-slots.js";
+import { listen } from "@videojs/utils/dom";
+//#region src/playback/behaviors/dom/sync-text-tracks.ts
+/**
+* **Own the text-track slots on the host media element, mirroring the SPF model.** When a presentation is resolved and
+* a media element is available, allocate one slot in `mediaElement.textTracks` per model text track — via creating
+* `<track>` children, since that's the only spec mechanism for adding _and_ removing entries to `textTracks` (no
+* `removeTextTrack` API exists). Once slots are provisioned, mirror the resolved `selectedTextTrackId` into their
+* `mode`s (one-way: state → DOM), and propagate user-initiated DOM `change` events back to `userTextTrackSelection` —
+* the standing _intent_ (a language-based partial, or `'off'`) that `switchTextTrack` resolves into
+* `selectedTextTrackId`. So non-SPF consumers (host-page captions buttons, browser native UI, video.js store) drive
+* selection by expressing intent, not by writing the resolved id.
+*
+* Single-positive-state reactor (`'preconditions-unmet'` ↔ `'sync-active'`): the entry allocates the slots, applies the
+* initial selection, attaches the `change` listener, and opens a brief Chromium settling-window guard — all
+* transition-driven, fire-once on state entry, with paired cleanup on state exit. A single `effects:` mirrors
+* subsequent `selectedTextTrackId` changes into `mode`s; that's the only continuous-reactivity concern.
+*
+* State-exit cleanup also sends a `'clear'` message to the `TextTracksActor` so its cue+segment cache (keyed by
+* trackId) is dropped alongside the DOM `<track>` slots. The actor itself is owned by `setupTextTrackActors` and bound
+* to mediaElement, not presentation, so it survives source resets; clearing its context here keeps the cache consistent
+* with the DOM. Without this, a subsequent presentation reusing a trackId would have `getSegmentsToLoad` treat its
+* segments as already-buffered and skip loading them.
+*
+* Single-writer separation: `selectedTextTrackId` is the resolved _output_ owned solely by `switchTextTrack`; this
+* behavior only reads it (to mirror modes). The write path here is `userTextTrackSelection` — the user-intent _input_ —
+* so DOM action and the resolver never contend for one slot. The intent isn't cleared on source unload (it's a standing
+* preference, like `userAudioTrackSelection`); `'off'` is written when the user disables all tracks via native UI.
+*
+* Echo guard: `selectedTextTrackId` is exactly the id this behavior last drove into the DOM, so a `change` event still
+* showing it is our own echo (or a resolver-driven correction — e.g. the picked track's CDN failed and the resolver
+* disabled it) and is ignored, never written back as a spurious user action. Only a showing id that _differs_ from the
+* resolved id is a real user pick. The settling-window guard additionally swallows Chromium's init-time auto-selection
+* before the resolved selection has settled.
+*/
+function deriveState(presentation, mediaElement) {
+	if (!mediaElement || !presentation) return "preconditions-unmet";
+	return getTracksByType(presentation, "text").length > 0 ? "sync-active" : "preconditions-unmet";
+}
+/**
+* Map the DOM-showing track back to standing user intent. No showing track is an explicit `'off'`. Otherwise prefer a
+* language-based partial (so the pick persists across source changes); fall back to `{ id }` for a track without a
+* language (precise within a source, just not portable).
+*/
+function deriveTextTrackIntent(showingId, modelTextTracks) {
+	if (!showingId) return "off";
+	const language = modelTextTracks.find((track) => track.id === showingId)?.language;
+	return language ? { language } : { id: showingId };
+}
+function syncTextTracksSetup({ state, context, config }) {
+	const { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia } = config;
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaElement.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"sync-active": {
+				entry: () => {
+					const mediaElement = context.mediaElement.get();
+					const modelTextTracks = getTracksByType(state.presentation.get(), "text");
+					addSubtitlesTracksToMedia(mediaElement, modelTextTracks);
+					syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());
+					let inSettlingWindow = true;
+					const settlingTimeout = setTimeout(() => {
+						inSettlingWindow = false;
+					}, 0);
+					const onChange = () => {
+						if (inSettlingWindow) {
+							syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());
+							return;
+						}
+						const showingId = getShowingSubtitlesTrackFromMedia(mediaElement)?.id || void 0;
+						if (showingId === state.selectedTextTrackId.get()) return;
+						state.userTextTrackSelection.set(deriveTextTrackIntent(showingId, modelTextTracks));
+					};
+					const unlisten = listen(mediaElement.textTracks, "change", onChange);
+					return () => {
+						unlisten();
+						clearTimeout(settlingTimeout);
+						removeAllSubtitlesTracksFromMedia(mediaElement);
+						peek(context.textTracksActor)?.send({ type: "clear" });
+					};
+				},
+				effects: () => {
+					const mediaElement = peek(context.mediaElement);
+					syncTextTrackModes(mediaElement.textTracks, state.selectedTextTrackId.get());
+				}
+			}
+		}
+	});
+}
+const syncTextTracks = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"selectedTextTrackId",
+		"userTextTrackSelection"
+	],
+	contextKeys: ["mediaElement", "textTracksActor"],
+	setup: syncTextTracksSetup
+});
+//#endregion
+export { syncTextTracks };
+
+//# sourceMappingURL=sync-text-tracks.js.map