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

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

@@ -0,0 +1,205 @@
+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";
+		return hasCodecs(getSelectedTrack({
+			presentation: state.presentation.get(),
+			[selectedKey]: state[selectedKey].get()
+		}, 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 bufferActor = createSourceBufferActor(createSourceBuffer(mediaSource, buildMimeCodec(getSelectedTrack({
+					presentation: state.presentation.get(),
+					[selectedKey]: state[selectedKey].get()
+				}, type))));
+				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\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/dev/playback/behaviors/dom/setup-mediasource.js

@@ -0,0 +1,114 @@
+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\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/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":";;;;;;UAgCiB;EACf,eAAe;EACf,kBAAkB,gBAAgB;EAClC,8BAA8B;;UAGf,8BAA8B,KAAK,kCAAkC;EACpF,yBAAyB,yBAAyB;;;;;;EAMlD,uBAAuB,qBAAqB;;cA8CjC,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\n * `mediaElement` is in scope, creates the `TextTracksActor` (bound to the\n * element's `textTracks`) and the `TextTrackSegmentLoaderActor` (bound to\n * that actor + the injected cue resolver), and publishes both on\n * `context`. On element identity change or behavior destroy, destroys both\n * actors and clears the slots.\n *\n * Single-resource synchronous create/destroy driven by one signal — the\n * simple-effect form is the right shape (per `behaviors.md` → \"Where both\n * shapes are legitimate\": criterion 4b applies; sole writer of\n * `textTracksActor` / `textTrackSegmentLoaderActor`, the effect's cleanup\n * return handles destroy + slot clear structurally).\n *\n * Pairs with the `loadTextTrackSegments` behavior (a per-type variant of\n * `setupSegmentLoading` in `load-segments.ts`), which only reads\n * `textTrackSegmentLoaderActor`. The cue resolver is injected via\n * `config` so this behavior owns the DOM-bound part of the text-track\n * 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\n   * with the `text` domain prefix to mirror the v/a `video`/`audioMessagePipelines`\n   * composition-config slots. Defaults (in the loader) to `resolveCues → 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    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":";;;;AAgDA,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;EACA,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,26 @@
+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\n * window update — **including while paused** (the seekable range must stay\n * current as the window slides, regardless of play state) — declare\n * `setLiveSeekableRange(start, end)` so the browser's `HTMLMediaElement.seekable`\n * reflects the live window (without it, `seekable` is empty under\n * `duration === Infinity`).\n *\n * The live window comes from `liveWindowFromState` (the shared derivation —\n * the intersection over the selected A/V tracks' windows); inert when it\n * returns `null` (VoD / ended live). Composed *before* `seekToLiveEdge`\n * so the range is declared before that behavior seeks the playhead into it (a\n * seek outside `seekable` is clamped).\n *\n * Duration is owned solely by `updateMediaSourceDuration`; this behavior only\n * declares the seekable range (`setLiveSeekableRange` requires only\n * `readyState === 'open'` per the W3C MSE spec, not a set `duration`).\n *\n * No `clearLiveSeekableRange()` on termination, by design: the MSE spec consults\n * the live seekable range *only* while `duration === Infinity`. When a live\n * stream ends, `endOfStream()` sets a finite duration and the UA derives\n * `seekable` from buffered + duration, ignoring the live range — so clearing is\n * unnecessary. Clearing on the `ENDLIST`→finite-`Track.duration` transition\n * (when the window goes `null`) would also be premature: `duration` is still\n * `Infinity` until `endOfStream`, so clearing would shrink `seekable` to\n * buffered-only while the stream is still 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\n * `presentation` in stateKeys while reading `selectedVideoTrackId` /\n * `selectedAudioTrackId` defensively (contributed by the switch* behaviors), so\n * it composes 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":";;;AA2CA,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;;;;;;;AAQA,MAAa,wBAIT;CACF,WAAW,CAAC,cAAc;CAC1B,aAAa,CAAC,aAAa;CAC3B,OAAO;AACT"}