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

package/dist/default/playback/behaviors/dom/end-of-stream.js

@@ -0,0 +1,178 @@
+import { computed, signal } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { effect } from "../../../core/signals/effect.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { isResolvedTrack } from "../../../media/types/index.js";
+import { findTrackById } from "../../../media/utils/tracks.js";
+import { getMaxBufferedEnd, waitForSourceBuffersReady } from "../../../media/dom/mse/duration.js";
+import { isLastSegmentAppended } from "../../../media/dom/mse/end-of-stream.js";
+import { onMediaSourceReadyStateChange } from "../../../media/dom/mse/mediasource-setup.js";
+//#region src/playback/behaviors/dom/end-of-stream.ts
+/**
+* **Drive each `open → ended` transition of the MediaSource.** Calls
+* `MediaSource.endOfStream()` once the temporally last segments of every
+* active buffer actor's currently-loading track are fully appended and
+* the user has reached them — letting the browser finalize duration and
+* fire `ended` on the media element.
+*
+* Re-fires on every subsequent `open → ended → open` cycle. Per the MSE
+* spec, `appendBuffer()` after `endOfStream()` transitions the MediaSource
+* back to `'open'`; seek-back replays and back-buffer refills that re-load
+* earlier segments take this path, so the behavior must call
+* `endOfStream()` again once the last segments are reappended. The reactor's
+* `'preconditions-unmet'` ↔ `'eos-ready'` cycle *is* the re-arm mechanism:
+* a successful `endOfStream()` flips `mediaSource.readyState` to `'ended'`,
+* which (via the local `msIsOpen` signal) exits `'eos-ready'`; the next
+* `'open'` re-evaluates preconditions and may re-enter.
+*
+* # Tracking what's in the buffer
+*
+* Each `SourceBufferActor` knows which track it's currently loading via
+* `initTrackId` (set on the most recent `append-init` message) and which
+* segments it has appended. `deriveState` iterates over the available
+* buffer actors (`[videoBufferActor, audioBufferActor].filter(Boolean)`),
+* resolves each to its track via `findTrackById`, and checks that track's
+* last segment is appended. This means audio-only / video-only / mixed
+* configurations compose uniformly — the body iterates whatever's in
+* scope. No reliance on `selectedTrackId` slots: the actor's view IS the
+* source of truth for "what's being loaded into this buffer."
+*
+* **Two-fire on mid-end ABR switches**: when a quality switch occurs near
+* end-of-stream, the actor's `initTrackId` still reflects the *old* track
+* until the new init segment is appended. The reactor may fire
+* `endOfStream()` against the old track's last-segment-appended state,
+* then the new init's `appendBuffer()` re-opens the MS, which re-arms us
+* to fire again once the new track's last segment lands. Functionally
+* correct (the browser re-fires `ended` after the re-arm), at the cost of
+* one extra call. Accepted as the price of dropping `selectedTrackId`
+* dependence.
+*
+* # Buffer-actor idle gate
+*
+* Each actor must be `'idle'` (no queued or in-flight tasks) before we
+* fire. `buffer.updating === false` alone is insufficient: for chunked
+* fMP4 streaming, `updateend` fires after each chunk while the actor's
+* for-await loop synchronously enqueues the next `appendBuffer()` — so
+* the buffer flips `!updating → updating` across a microtask boundary.
+* The actor's `'updating'` state spans the entire multi-chunk append, so
+* `actor.snapshot.value === 'idle'` is the canonical "no more pending or
+* in-flight work" oracle.
+*
+* This bet (actor models the pipeline; `mediaSource.sourceBuffers` models
+* DOM state) is durable as long as the segment loader is the sole writer
+* of `appendBuffer()` calls. A future loop-mode that auto-fetches earlier
+* segments mid-`ended` would require a broader coordination story
+* between SourceBuffers and the MediaSource — possibly via a
+* `MediaSourceActor` — and that's where this gate would want
+* re-evaluating.
+*
+* # currentTime gate
+*
+* `currentTime` must have reached at least one active track's last
+* segment startTime. Prevents `'eos-ready'` entry when a back-buffer
+* `remove()` / `appendBuffer()` briefly re-opens the MediaSource while
+* the user is mid-stream. HLS rendition time-alignment means any active
+* track works as the reference.
+*
+* # MS readyState — local subscription
+*
+* The behavior subscribes to `mediaSource`'s readyState changes inside
+* its setup (via `onMediaSourceReadyStateChange`) and mirrors `'open'` to
+* a behavior-local `msIsOpen` signal that `deriveState` reads. No shared
+* `mediaSourceReadyState` slot dependency. Anticipates a future
+* `MediaSourceActor` whose snapshot would expose the same signal — the
+* consumer code wouldn't change.
+*
+* # `endOfStream` entry sequence
+*
+* 1. Wait for all SourceBuffers to be idle (DOM-level — defensive,
+*    should already hold given the actor-idle gate in `deriveState`).
+* 2. Set `mediaSource.duration` from `getMaxBufferedEnd` to match actual
+*    container timestamps (`endOfStream()` only clamps up implicitly;
+*    setting it explicitly here keeps the final value deterministic).
+* 3. Call `mediaSource.endOfStream()`.
+*
+* State-exit cleanup (`controller.abort()`) cancels any in-flight wait
+* on source unload, presentation replace, or behavior destroy.
+*
+* # Coordination with `updateMediaSourceDuration`
+*
+* `updateMediaSourceDuration` writes the initial `mediaSource.duration`
+* from `presentation.duration` once per source; this behavior writes the
+* final value from the buffered end. Decision domains don't overlap.
+*/
+function deriveState(presentation, mediaSource, msIsOpen, videoBufferActor, audioBufferActor, currentTime) {
+	if (!mediaSource || !presentation || !msIsOpen) return "preconditions-unmet";
+	const actors = [videoBufferActor, audioBufferActor].filter((a) => a !== void 0);
+	if (actors.length === 0) return "preconditions-unmet";
+	let lastSegStart;
+	for (const actor of actors) {
+		const snapshot = actor.snapshot.get();
+		if (snapshot.value !== "idle") return "preconditions-unmet";
+		const { initTrackId, segments: appended } = snapshot.context;
+		if (!initTrackId) return "preconditions-unmet";
+		const track = findTrackById(presentation, initTrackId);
+		if (!track || !isResolvedTrack(track)) return "preconditions-unmet";
+		if (!isLastSegmentAppended(track.segments, appended)) return "preconditions-unmet";
+		if (track.segments.length > 0) {
+			const start = track.segments[track.segments.length - 1].startTime;
+			if (lastSegStart === void 0 || start > lastSegStart) lastSegStart = start;
+		}
+	}
+	if (lastSegStart !== void 0 && (currentTime ?? 0) < lastSegStart) return "preconditions-unmet";
+	return "eos-ready";
+}
+function endOfStreamSetup({ state, context }) {
+	const msIsOpen = signal(false);
+	const cleanupMsListener = effect(() => {
+		const mediaSource = context.mediaSource.get();
+		if (!mediaSource) {
+			msIsOpen.set(false);
+			return;
+		}
+		msIsOpen.set(mediaSource.readyState === "open");
+		const controller = new AbortController();
+		onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {
+			msIsOpen.set(rs === "open");
+		});
+		return () => controller.abort();
+	});
+	const derivedStateSignal = computed(() => deriveState(state.presentation.get(), context.mediaSource.get(), msIsOpen.get(), context.videoBufferActor.get(), context.audioBufferActor.get(), state.currentTime.get()));
+	const reactor = createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			"eos-ready": { entry: () => {
+				const mediaSource = context.mediaSource.get();
+				const controller = new AbortController();
+				const endStreamWhenReady = async () => {
+					await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);
+					if (controller.signal.aborted) return;
+					const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);
+					if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;
+					mediaSource.endOfStream();
+				};
+				endStreamWhenReady().catch((err) => console.error("Failed to call endOfStream:", err));
+				return () => controller.abort();
+			} }
+		}
+	});
+	return () => {
+		cleanupMsListener();
+		reactor.destroy();
+	};
+}
+const endOfStream = defineBehavior({
+	stateKeys: ["presentation", "currentTime"],
+	contextKeys: [
+		"mediaSource",
+		"videoBufferActor",
+		"audioBufferActor"
+	],
+	setup: endOfStreamSetup
+});
+//#endregion
+export { endOfStream };
+
+//# sourceMappingURL=end-of-stream.js.map

package/dist/default/playback/behaviors/dom/end-of-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/end-of-stream.ts"],"sourcesContent":["/**\n * **Drive each `open → ended` transition of the MediaSource.** Calls\n * `MediaSource.endOfStream()` once the temporally last segments of every\n * active buffer actor's currently-loading track are fully appended and\n * the user has reached them — letting the browser finalize duration and\n * fire `ended` on the media element.\n *\n * Re-fires on every subsequent `open → ended → open` cycle. Per the MSE\n * spec, `appendBuffer()` after `endOfStream()` transitions the MediaSource\n * back to `'open'`; seek-back replays and back-buffer refills that re-load\n * earlier segments take this path, so the behavior must call\n * `endOfStream()` again once the last segments are reappended. The reactor's\n * `'preconditions-unmet'` ↔ `'eos-ready'` cycle *is* the re-arm mechanism:\n * a successful `endOfStream()` flips `mediaSource.readyState` to `'ended'`,\n * which (via the local `msIsOpen` signal) exits `'eos-ready'`; the next\n * `'open'` re-evaluates preconditions and may re-enter.\n *\n * # Tracking what's in the buffer\n *\n * Each `SourceBufferActor` knows which track it's currently loading via\n * `initTrackId` (set on the most recent `append-init` message) and which\n * segments it has appended. `deriveState` iterates over the available\n * buffer actors (`[videoBufferActor, audioBufferActor].filter(Boolean)`),\n * resolves each to its track via `findTrackById`, and checks that track's\n * last segment is appended. This means audio-only / video-only / mixed\n * configurations compose uniformly — the body iterates whatever's in\n * scope. No reliance on `selectedTrackId` slots: the actor's view IS the\n * source of truth for \"what's being loaded into this buffer.\"\n *\n * **Two-fire on mid-end ABR switches**: when a quality switch occurs near\n * end-of-stream, the actor's `initTrackId` still reflects the *old* track\n * until the new init segment is appended. The reactor may fire\n * `endOfStream()` against the old track's last-segment-appended state,\n * then the new init's `appendBuffer()` re-opens the MS, which re-arms us\n * to fire again once the new track's last segment lands. Functionally\n * correct (the browser re-fires `ended` after the re-arm), at the cost of\n * one extra call. Accepted as the price of dropping `selectedTrackId`\n * dependence.\n *\n * # Buffer-actor idle gate\n *\n * Each actor must be `'idle'` (no queued or in-flight tasks) before we\n * fire. `buffer.updating === false` alone is insufficient: for chunked\n * fMP4 streaming, `updateend` fires after each chunk while the actor's\n * for-await loop synchronously enqueues the next `appendBuffer()` — so\n * the buffer flips `!updating → updating` across a microtask boundary.\n * The actor's `'updating'` state spans the entire multi-chunk append, so\n * `actor.snapshot.value === 'idle'` is the canonical \"no more pending or\n * in-flight work\" oracle.\n *\n * This bet (actor models the pipeline; `mediaSource.sourceBuffers` models\n * DOM state) is durable as long as the segment loader is the sole writer\n * of `appendBuffer()` calls. A future loop-mode that auto-fetches earlier\n * segments mid-`ended` would require a broader coordination story\n * between SourceBuffers and the MediaSource — possibly via a\n * `MediaSourceActor` — and that's where this gate would want\n * re-evaluating.\n *\n * # currentTime gate\n *\n * `currentTime` must have reached at least one active track's last\n * segment startTime. Prevents `'eos-ready'` entry when a back-buffer\n * `remove()` / `appendBuffer()` briefly re-opens the MediaSource while\n * the user is mid-stream. HLS rendition time-alignment means any active\n * track works as the reference.\n *\n * # MS readyState — local subscription\n *\n * The behavior subscribes to `mediaSource`'s readyState changes inside\n * its setup (via `onMediaSourceReadyStateChange`) and mirrors `'open'` to\n * a behavior-local `msIsOpen` signal that `deriveState` reads. No shared\n * `mediaSourceReadyState` slot dependency. Anticipates a future\n * `MediaSourceActor` whose snapshot would expose the same signal — the\n * consumer code wouldn't change.\n *\n * # `endOfStream` entry sequence\n *\n * 1. Wait for all SourceBuffers to be idle (DOM-level — defensive,\n *    should already hold given the actor-idle gate in `deriveState`).\n * 2. Set `mediaSource.duration` from `getMaxBufferedEnd` to match actual\n *    container timestamps (`endOfStream()` only clamps up implicitly;\n *    setting it explicitly here keeps the final value deterministic).\n * 3. Call `mediaSource.endOfStream()`.\n *\n * State-exit cleanup (`controller.abort()`) cancels any in-flight wait\n * on source unload, presentation replace, or behavior destroy.\n *\n * # Coordination with `updateMediaSourceDuration`\n *\n * `updateMediaSourceDuration` writes the initial `mediaSource.duration`\n * from `presentation.duration` once per source; this behavior writes the\n * final value from the buffered end. Decision domains don't overlap.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { effect } from '../../../core/signals/effect';\nimport { computed, type ReadonlySignal, signal } from '../../../core/signals/primitives';\nimport { getMaxBufferedEnd, waitForSourceBuffersReady } from '../../../media/dom/mse/duration';\nimport { isLastSegmentAppended } from '../../../media/dom/mse/end-of-stream';\nimport { onMediaSourceReadyStateChange } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation } from '../../../media/types';\nimport { isResolvedTrack } from '../../../media/types';\nimport { findTrackById } from '../../../media/utils/tracks';\nimport type { SourceBufferActor } from '../../actors/dom/source-buffer';\n\nexport interface EndOfStreamState {\n  presentation?: MaybeResolvedPresentation;\n  currentTime?: number;\n}\n\nexport interface EndOfStreamContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n}\n\ntype EndOfStreamFsmState = 'preconditions-unmet' | 'eos-ready';\n\nfunction deriveState(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined,\n  msIsOpen: boolean,\n  videoBufferActor: SourceBufferActor | undefined,\n  audioBufferActor: SourceBufferActor | undefined,\n  currentTime: number | undefined\n): EndOfStreamFsmState {\n  if (!mediaSource || !presentation || !msIsOpen) return 'preconditions-unmet';\n\n  const actors = [videoBufferActor, audioBufferActor].filter((a): a is SourceBufferActor => a !== undefined);\n  // No active buffer actors means setup hasn't completed wiring yet.\n  if (actors.length === 0) return 'preconditions-unmet';\n\n  // Track the latest last-segment startTime across actors as the\n  // currentTime reference. HLS rendition time-alignment makes any active\n  // track usable; using the max is safest when timings drift slightly.\n  let lastSegStart: number | undefined;\n\n  for (const actor of actors) {\n    const snapshot = actor.snapshot.get();\n    if (snapshot.value !== 'idle') return 'preconditions-unmet';\n\n    const { initTrackId, segments: appended } = snapshot.context;\n    if (!initTrackId) return 'preconditions-unmet';\n\n    const track = findTrackById(presentation, initTrackId);\n    if (!track || !isResolvedTrack(track)) return 'preconditions-unmet';\n    if (!isLastSegmentAppended(track.segments, appended)) return 'preconditions-unmet';\n\n    if (track.segments.length > 0) {\n      const start = track.segments[track.segments.length - 1]!.startTime;\n      if (lastSegStart === undefined || start > lastSegStart) lastSegStart = start;\n    }\n  }\n\n  if (lastSegStart !== undefined && (currentTime ?? 0) < lastSegStart) {\n    return 'preconditions-unmet';\n  }\n\n  return 'eos-ready';\n}\n\nfunction endOfStreamSetup({\n  state,\n  context,\n}: {\n  state: {\n    presentation: ReadonlySignal<EndOfStreamState['presentation']>;\n    currentTime: ReadonlySignal<EndOfStreamState['currentTime']>;\n  };\n  context: {\n    mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']>;\n    videoBufferActor: ReadonlySignal<EndOfStreamContext['videoBufferActor']>;\n    audioBufferActor: ReadonlySignal<EndOfStreamContext['audioBufferActor']>;\n  };\n}): () => void {\n  // Behavior-local mirror of `mediaSource.readyState === 'open'`. Subscribes\n  // to MS events whenever a MediaSource is in scope; tears down when the\n  // MS is swapped or the behavior destroys. Anticipates a future\n  // `MediaSourceActor` whose snapshot would expose the same value — the\n  // consumer code (deriveState) wouldn't change.\n  const msIsOpen = signal(false);\n  const cleanupMsListener = effect(() => {\n    const mediaSource = context.mediaSource.get();\n    if (!mediaSource) {\n      msIsOpen.set(false);\n      return;\n    }\n    msIsOpen.set(mediaSource.readyState === 'open');\n    const controller = new AbortController();\n    onMediaSourceReadyStateChange(mediaSource, controller.signal, (rs) => {\n      msIsOpen.set(rs === 'open');\n    });\n    return () => controller.abort();\n  });\n\n  const derivedStateSignal = computed(() =>\n    deriveState(\n      state.presentation.get(),\n      context.mediaSource.get(),\n      msIsOpen.get(),\n      context.videoBufferActor.get(),\n      context.audioBufferActor.get(),\n      state.currentTime.get()\n    )\n  );\n\n  const reactor = createMachineReactor<EndOfStreamFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'eos-ready': {\n        // entry body is auto-untracked. deriveState handles source resets\n        // and the MS readyState flip from 'open' to 'ended' that\n        // endOfStream() produces; this entry resolves the MSE-spec\n        // preconditions and binds its cleanup (abort) to state exit +\n        // destroy.\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const controller = new AbortController();\n\n          const endStreamWhenReady = async () => {\n            // Defensive: the actor-idle gate in deriveState should mean\n            // buffers are already settled, but a microtask boundary\n            // between deriveState's read and entry firing leaves a thin\n            // gap. The DOM-level wait closes it.\n            await waitForSourceBuffersReady(mediaSource.sourceBuffers, controller.signal);\n            if (controller.signal.aborted) return;\n\n            // MSE spec: duration cannot be less than any buffered range, and\n            // endOfStream() will only clamp up implicitly. Setting it\n            // explicitly here from actual container timestamps keeps the\n            // final value deterministic for assets whose declared duration\n            // disagrees with the buffered end (common with CMAF).\n            const bufferedEnd = getMaxBufferedEnd(mediaSource.sourceBuffers);\n            if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;\n\n            mediaSource.endOfStream();\n          };\n\n          endStreamWhenReady().catch((err) => console.error('Failed to call endOfStream:', err));\n\n          return () => controller.abort();\n        },\n      },\n    },\n  });\n\n  return () => {\n    cleanupMsListener();\n    reactor.destroy();\n  };\n}\n\nexport const endOfStream = defineBehavior({\n  stateKeys: ['presentation', 'currentTime'],\n  contextKeys: ['mediaSource', 'videoBufferActor', 'audioBufferActor'],\n  setup: endOfStreamSetup,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHA,SAAS,YACP,cACA,aACA,UACA,kBACA,kBACA,aACqB;AACrB,KAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,SAAU,QAAO;CAEvD,MAAM,SAAS,CAAC,kBAAkB,iBAAiB,CAAC,QAAQ,MAA8B,MAAM,KAAA,EAAU;AAE1G,KAAI,OAAO,WAAW,EAAG,QAAO;CAKhC,IAAI;AAEJ,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM,SAAS,KAAK;AACrC,MAAI,SAAS,UAAU,OAAQ,QAAO;EAEtC,MAAM,EAAE,aAAa,UAAU,aAAa,SAAS;AACrD,MAAI,CAAC,YAAa,QAAO;EAEzB,MAAM,QAAQ,cAAc,cAAc,YAAY;AACtD,MAAI,CAAC,SAAS,CAAC,gBAAgB,MAAM,CAAE,QAAO;AAC9C,MAAI,CAAC,sBAAsB,MAAM,UAAU,SAAS,CAAE,QAAO;AAE7D,MAAI,MAAM,SAAS,SAAS,GAAG;GAC7B,MAAM,QAAQ,MAAM,SAAS,MAAM,SAAS,SAAS,GAAI;AACzD,OAAI,iBAAiB,KAAA,KAAa,QAAQ,aAAc,gBAAe;;;AAI3E,KAAI,iBAAiB,KAAA,MAAc,eAAe,KAAK,aACrD,QAAO;AAGT,QAAO;;AAGT,SAAS,iBAAiB,EACxB,OACA,WAWa;CAMb,MAAM,WAAW,OAAO,MAAM;CAC9B,MAAM,oBAAoB,aAAa;EACrC,MAAM,cAAc,QAAQ,YAAY,KAAK;AAC7C,MAAI,CAAC,aAAa;AAChB,YAAS,IAAI,MAAM;AACnB;;AAEF,WAAS,IAAI,YAAY,eAAe,OAAO;EAC/C,MAAM,aAAa,IAAI,iBAAiB;AACxC,gCAA8B,aAAa,WAAW,SAAS,OAAO;AACpE,YAAS,IAAI,OAAO,OAAO;IAC3B;AACF,eAAa,WAAW,OAAO;GAC/B;CAEF,MAAM,qBAAqB,eACzB,YACE,MAAM,aAAa,KAAK,EACxB,QAAQ,YAAY,KAAK,EACzB,SAAS,KAAK,EACd,QAAQ,iBAAiB,KAAK,EAC9B,QAAQ,iBAAiB,KAAK,EAC9B,MAAM,YAAY,KAAK,CACxB,CACF;CAED,MAAM,UAAU,qBAA0C;EACxD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,aAAa,EAMX,aAAa;IACX,MAAM,cAAc,QAAQ,YAAY,KAAK;IAC7C,MAAM,aAAa,IAAI,iBAAiB;IAExC,MAAM,qBAAqB,YAAY;AAKrC,WAAM,0BAA0B,YAAY,eAAe,WAAW,OAAO;AAC7E,SAAI,WAAW,OAAO,QAAS;KAO/B,MAAM,cAAc,kBAAkB,YAAY,cAAc;AAChE,SAAI,cAAc,EAAG,aAAY,WAAW;AAE5C,iBAAY,aAAa;;AAG3B,wBAAoB,CAAC,OAAO,QAAQ,QAAQ,MAAM,+BAA+B,IAAI,CAAC;AAEtF,iBAAa,WAAW,OAAO;MAElC;GACF;EACF,CAAC;AAEF,cAAa;AACX,qBAAmB;AACnB,UAAQ,SAAS;;;AAIrB,MAAa,cAAc,eAAe;CACxC,WAAW,CAAC,gBAAgB,cAAc;CAC1C,aAAa;EAAC;EAAe;EAAoB;EAAmB;CACpE,OAAO;CACR,CAAC"}

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

@@ -0,0 +1,177 @@
+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 { DEFAULT_FORWARD_BUFFER_CONFIG, segmentStartForTime } from "../../../media/buffer/forward-buffer.js";
+import { findResolvedAudioTrack, findResolvedTextTrack, findResolvedVideoTrack } from "../../../media/utils/tracks.js";
+import { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../track-types.js";
+//#region src/playback/behaviors/dom/load-segments.ts
+/**
+* **Per-type segment loading dispatch.** Per available track type (video /
+* audio / text), reads the per-type segment-loader actor from context and
+* sends typed `'load'` messages whenever a meaningful loading condition
+* changes (selected track, current time crossing a segment boundary).
+*
+* Loader-actor lifecycle is owned upstream:
+* - Video: `setupVideoBufferActors`
+* - Audio: `setupAudioBufferActors`
+* - Text: `setupTextTrackActors`
+*
+* This behavior is pure-consumer: it reads `context[loaderKey]` and
+* dispatches typed messages via the variant's per-type `findResolvedTrack`
+* resolver.
+*
+* # Load modes as reactor states
+*
+* Four states encode the load-gating policy directly:
+*
+* - `'preconditions-unmet'` — no loader actor in context, or the selected
+*   track hasn't resolved.
+* - `'dormant'` — `preload === 'none' && !loadActivated`. Nothing fires.
+* - `'metadata-only'` — `!loadActivated && preload !== 'auto' && preload !== 'none'`.
+*   Fires an init-segment-only `load` message **once on entry**. The
+*   variant's loader actor decides what to do — v/a's actor fetches the
+*   init segment; text's actor no-ops (no init concept).
+* - `'full-range'` — `loadActivated || preload === 'auto'`. Effect re-fires
+*   on selected-track change and on segment-boundary crossing.
+*
+* # Per-type parameterization (inference-driven)
+*
+* The helper is generic over `Track` — the resolved-track type. Each
+* variant supplies its own `findResolvedTrack` resolver via config; TS
+* infers `Track` from the resolver's return type. The loader signal's
+* value type is constrained to `SegmentLoaderLike<Track>` — anything with
+* a `send` method accepting the `Track`-parameterized message. Concrete
+* actor types (`SegmentLoaderActor`, `TextTrackSegmentLoaderActor`)
+* satisfy this via function-parameter contravariance: an actor whose
+* `.send` accepts a wider track type is assignable to a slot expecting a
+* narrower track type.
+*
+* No widening of actor message types is needed; no casts inside the
+* helper. Per-variant wiring (right loader paired with right resolver)
+* is enforced at the variant call site.
+*/
+/**
+* Specialization helper. Generic over `Track` (inferred from
+* `findResolvedTrack`'s return type). The loader value type is
+* constrained to `SegmentLoaderLike<Track>` — concrete actor types
+* (whose `.send` accepts a wider track union) satisfy this via
+* function-parameter contravariance.
+*
+* Tracks that the helper handles must have a `segments` field — used by
+* `segmentBoundarySignal` to compute the load-anchor boundary. Each
+* variant's resolver narrows to the right resolved-track shape.
+*/
+function setupSegmentLoading({ state, context, config }) {
+	const { selectedKey, loaderKey, findResolvedTrack } = config;
+	const bufferDuration = config.forwardBuffer?.bufferDuration ?? DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration;
+	const selectedTrack = computed(() => findResolvedTrack(state.presentation.get(), state[selectedKey].get()));
+	const segmentBoundarySignal = computed(() => {
+		const track = selectedTrack.get();
+		if (!track) return void 0;
+		return segmentStartForTime(state.currentTime.get() ?? 0, track.segments);
+	});
+	const derivedStateSignal = computed(() => {
+		if (!context[loaderKey].get() || !selectedTrack.get()) return "preconditions-unmet";
+		if (state.loadActivated.get() || state.preload.get() === "auto") return "full-range";
+		if (state.preload.get() === "none") return "dormant";
+		return "metadata-only";
+	});
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": {},
+			dormant: {},
+			"metadata-only": { entry: () => {
+				const track = selectedTrack.get();
+				context[loaderKey].get().send({
+					type: "load",
+					track
+				});
+			} },
+			"full-range": { effects: () => {
+				const track = selectedTrack.get();
+				segmentBoundarySignal.get();
+				const currentTime = peek(state.currentTime) ?? 0;
+				peek(context[loaderKey]).send({
+					type: "load",
+					track,
+					range: {
+						start: currentTime,
+						end: currentTime + bufferDuration
+					}
+				});
+			} }
+		}
+	});
+}
+const VIDEO_SEGMENT_LOADING_CONFIG = {
+	...VIDEO_TYPE_CONFIG,
+	findResolvedTrack: findResolvedVideoTrack
+};
+const AUDIO_SEGMENT_LOADING_CONFIG = {
+	...AUDIO_TYPE_CONFIG,
+	findResolvedTrack: findResolvedAudioTrack
+};
+const TEXT_SEGMENT_LOADING_CONFIG = {
+	...TEXT_TYPE_CONFIG,
+	findResolvedTrack: findResolvedTextTrack
+};
+const loadVideoSegments = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"preload",
+		"currentTime",
+		"loadActivated",
+		"selectedVideoTrackId"
+	],
+	contextKeys: ["videoSegmentLoaderActor"],
+	setup: ({ state, context, config = {} }) => setupSegmentLoading({
+		state,
+		context,
+		config: {
+			...VIDEO_SEGMENT_LOADING_CONFIG,
+			...config
+		}
+	})
+});
+const loadAudioSegments = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"preload",
+		"currentTime",
+		"loadActivated",
+		"selectedAudioTrackId"
+	],
+	contextKeys: ["audioSegmentLoaderActor"],
+	setup: ({ state, context, config = {} }) => setupSegmentLoading({
+		state,
+		context,
+		config: {
+			...AUDIO_SEGMENT_LOADING_CONFIG,
+			...config
+		}
+	})
+});
+const loadTextTrackSegments = defineBehavior({
+	stateKeys: [
+		"presentation",
+		"preload",
+		"currentTime",
+		"loadActivated",
+		"selectedTextTrackId"
+	],
+	contextKeys: ["textTrackSegmentLoaderActor"],
+	setup: ({ state, context, config = {} }) => setupSegmentLoading({
+		state,
+		context,
+		config: {
+			...TEXT_SEGMENT_LOADING_CONFIG,
+			...config
+		}
+	})
+});
+//#endregion
+export { loadAudioSegments, loadTextTrackSegments, loadVideoSegments };
+
+//# sourceMappingURL=load-segments.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load-segments.js","names":[],"sources":["../../../../../src/playback/behaviors/dom/load-segments.ts"],"sourcesContent":["/**\n * **Per-type segment loading dispatch.** Per available track type (video /\n * audio / text), reads the per-type segment-loader actor from context and\n * sends typed `'load'` messages whenever a meaningful loading condition\n * changes (selected track, current time crossing a segment boundary).\n *\n * Loader-actor lifecycle is owned upstream:\n * - Video: `setupVideoBufferActors`\n * - Audio: `setupAudioBufferActors`\n * - Text: `setupTextTrackActors`\n *\n * This behavior is pure-consumer: it reads `context[loaderKey]` and\n * dispatches typed messages via the variant's per-type `findResolvedTrack`\n * resolver.\n *\n * # Load modes as reactor states\n *\n * Four states encode the load-gating policy directly:\n *\n * - `'preconditions-unmet'` — no loader actor in context, or the selected\n *   track hasn't resolved.\n * - `'dormant'` — `preload === 'none' && !loadActivated`. Nothing fires.\n * - `'metadata-only'` — `!loadActivated && preload !== 'auto' && preload !== 'none'`.\n *   Fires an init-segment-only `load` message **once on entry**. The\n *   variant's loader actor decides what to do — v/a's actor fetches the\n *   init segment; text's actor no-ops (no init concept).\n * - `'full-range'` — `loadActivated || preload === 'auto'`. Effect re-fires\n *   on selected-track change and on segment-boundary crossing.\n *\n * # Per-type parameterization (inference-driven)\n *\n * The helper is generic over `Track` — the resolved-track type. Each\n * variant supplies its own `findResolvedTrack` resolver via config; TS\n * infers `Track` from the resolver's return type. The loader signal's\n * value type is constrained to `SegmentLoaderLike<Track>` — anything with\n * a `send` method accepting the `Track`-parameterized message. Concrete\n * actor types (`SegmentLoaderActor`, `TextTrackSegmentLoaderActor`)\n * satisfy this via function-parameter contravariance: an actor whose\n * `.send` accepts a wider track type is assignable to a slot expecting a\n * narrower track type.\n *\n * No widening of actor message types is needed; no casts inside the\n * helper. Per-variant wiring (right loader paired with right resolver)\n * is enforced at the variant call site.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, peek, type ReadonlySignal } from '../../../core/signals/primitives';\nimport {\n  DEFAULT_FORWARD_BUFFER_CONFIG,\n  type ForwardBufferConfig,\n  segmentStartForTime,\n} from '../../../media/buffer/forward-buffer';\nimport type { MaybeResolvedPresentation, Segment } from '../../../media/types';\nimport { findResolvedAudioTrack, findResolvedTextTrack, findResolvedVideoTrack } from '../../../media/utils/tracks';\nimport type { BufferState, SegmentLoaderActor, SourceBufferState } from '../../actors/dom/segment-loader';\nimport type { TextTrackSegmentLoaderActor } from '../../actors/text-track-segment-loader';\nimport { AUDIO_TYPE_CONFIG, TEXT_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../track-types';\n\n// Re-export buffer state types for consumers that import them from this module.\nexport type { BufferState, SourceBufferState };\n\n// ============================================================================\n// STATE & CONTEXT\n// ============================================================================\n\n/** State shape for segment loading. */\nexport interface SegmentLoadingState {\n  presentation?: MaybeResolvedPresentation;\n  preload?: string;\n  /** Current playback position in seconds. Defaults to 0 when undefined. */\n  currentTime?: number;\n  /** True once a preload-overriding event has fired for the current source. */\n  loadActivated?: boolean;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  selectedTextTrackId?: string;\n}\n\n/** Context shape for segment loading. Each variant only consumes its own type's loader actor. */\nexport interface SegmentLoadingContext {\n  videoSegmentLoaderActor?: SegmentLoaderActor;\n  audioSegmentLoaderActor?: SegmentLoaderActor;\n  textTrackSegmentLoaderActor?: TextTrackSegmentLoaderActor;\n}\n\n// ============================================================================\n// REACTOR\n// ============================================================================\n\ntype SegmentLoadingFsmState = 'preconditions-unmet' | 'dormant' | 'metadata-only' | 'full-range';\n\ntype SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId' | 'selectedTextTrackId';\ntype SegmentLoaderActorKey = 'videoSegmentLoaderActor' | 'audioSegmentLoaderActor' | 'textTrackSegmentLoaderActor';\n\ntype SegmentLoadingStateMap<K extends SelectedTrackKey> = {\n  presentation: ReadonlySignal<SegmentLoadingState['presentation']>;\n  preload: ReadonlySignal<SegmentLoadingState['preload']>;\n  currentTime: ReadonlySignal<SegmentLoadingState['currentTime']>;\n  loadActivated: ReadonlySignal<SegmentLoadingState['loadActivated']>;\n} & { [P in K]: ReadonlySignal<SegmentLoadingState[P]> };\n\n/** Shared `'load'` message shape parameterized over the resolved track type. */\ninterface LoadMessage<Track> {\n  type: 'load';\n  track: Track;\n  range?: { start: number; end: number };\n}\n\n/** Structural constraint for any segment-loader-style actor. */\ninterface SegmentLoaderLike<Track> {\n  send: (message: LoadMessage<Track>) => void;\n}\n\n/**\n * Specialization helper. Generic over `Track` (inferred from\n * `findResolvedTrack`'s return type). The loader value type is\n * constrained to `SegmentLoaderLike<Track>` — concrete actor types\n * (whose `.send` accepts a wider track union) satisfy this via\n * function-parameter contravariance.\n *\n * Tracks that the helper handles must have a `segments` field — used by\n * `segmentBoundarySignal` to compute the load-anchor boundary. Each\n * variant's resolver narrows to the right resolved-track shape.\n */\nfunction setupSegmentLoading<\n  K extends SelectedTrackKey,\n  L extends SegmentLoaderActorKey,\n  Track extends { segments: readonly Segment[] },\n>({\n  state,\n  context,\n  config,\n}: {\n  state: SegmentLoadingStateMap<K>;\n  context: { [P in L]: ReadonlySignal<SegmentLoaderLike<Track> | undefined> };\n  config: {\n    selectedKey: K;\n    loaderKey: L;\n    findResolvedTrack: (\n      presentation: MaybeResolvedPresentation | undefined,\n      trackId: string | undefined\n    ) => Track | undefined;\n    forwardBuffer?: Partial<ForwardBufferConfig>;\n  };\n}): Reactor<SegmentLoadingFsmState | 'destroying' | 'destroyed'> {\n  const { selectedKey, loaderKey, findResolvedTrack } = config;\n  const bufferDuration = config.forwardBuffer?.bufferDuration ?? DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration;\n\n  const selectedTrack = computed<Track | undefined>(() =>\n    findResolvedTrack(state.presentation.get(), state[selectedKey].get())\n  );\n\n  // Segment-boundary signal — `segmentStartForTime` returns the same number\n  // while `currentTime` stays inside one segment, so signal-polyfill's\n  // `Object.is` equality on this computed dedups within-segment ticks.\n  const segmentBoundarySignal = computed(() => {\n    const track = selectedTrack.get();\n    if (!track) return undefined;\n    return segmentStartForTime(state.currentTime.get() ?? 0, track.segments);\n  });\n\n  const derivedStateSignal = computed<SegmentLoadingFsmState>(() => {\n    if (!context[loaderKey].get() || !selectedTrack.get()) return 'preconditions-unmet';\n    if (state.loadActivated.get() || state.preload.get() === 'auto') return 'full-range';\n    if (state.preload.get() === 'none') return 'dormant';\n    return 'metadata-only';\n  });\n\n  return createMachineReactor<SegmentLoadingFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n      dormant: {},\n      'metadata-only': {\n        // Fires once on entry. Matches HTMLMediaElement's preload='metadata'\n        // semantics — load enough to surface metadata for the entry-time\n        // selection. Each variant's loader decides what to do: v/a's actor\n        // fetches the init segment; text's actor treats no-range as a\n        // no-op. Selection changes while still in `'metadata-only'` are\n        // intentionally not followed.\n        entry: () => {\n          const track = selectedTrack.get()!;\n          context[loaderKey].get()!.send({ type: 'load', track });\n        },\n      },\n      'full-range': {\n        // Re-fires on selected-track changes and on segment-boundary\n        // crossings. The loader and `currentTime` are peeked — the\n        // boundary-dedup signal already handles re-firing policy.\n        effects: () => {\n          const track = selectedTrack.get()!;\n          segmentBoundarySignal.get();\n          const currentTime = peek(state.currentTime) ?? 0;\n          peek(context[loaderKey])!.send({\n            type: 'load',\n            track,\n            range: { start: currentTime, end: currentTime + bufferDuration },\n          });\n        },\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Per-helper-per-type configs — defaults that variants spread engine config over\n// ============================================================================\n\nconst VIDEO_SEGMENT_LOADING_CONFIG = {\n  ...VIDEO_TYPE_CONFIG,\n  findResolvedTrack: findResolvedVideoTrack,\n} as const;\n\nconst AUDIO_SEGMENT_LOADING_CONFIG = {\n  ...AUDIO_TYPE_CONFIG,\n  findResolvedTrack: findResolvedAudioTrack,\n} as const;\n\nconst TEXT_SEGMENT_LOADING_CONFIG = {\n  ...TEXT_TYPE_CONFIG,\n  findResolvedTrack: findResolvedTextTrack,\n} as const;\n\n// ============================================================================\n// Specialized exports — one per media type\n// ============================================================================\n\nexport const loadVideoSegments = defineBehavior({\n  stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedVideoTrackId'],\n  contextKeys: ['videoSegmentLoaderActor'],\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: SegmentLoadingStateMap<'selectedVideoTrackId'>;\n    context: {\n      videoSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['videoSegmentLoaderActor']>;\n    };\n    config?: object;\n  }) =>\n    setupSegmentLoading({\n      state,\n      context,\n      config: { ...VIDEO_SEGMENT_LOADING_CONFIG, ...config },\n    }),\n});\n\nexport const loadAudioSegments = defineBehavior({\n  stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedAudioTrackId'],\n  contextKeys: ['audioSegmentLoaderActor'],\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: SegmentLoadingStateMap<'selectedAudioTrackId'>;\n    context: {\n      audioSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['audioSegmentLoaderActor']>;\n    };\n    config?: object;\n  }) =>\n    setupSegmentLoading({\n      state,\n      context,\n      config: { ...AUDIO_SEGMENT_LOADING_CONFIG, ...config },\n    }),\n});\n\nexport const loadTextTrackSegments = defineBehavior({\n  stateKeys: ['presentation', 'preload', 'currentTime', 'loadActivated', 'selectedTextTrackId'],\n  contextKeys: ['textTrackSegmentLoaderActor'],\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: SegmentLoadingStateMap<'selectedTextTrackId'>;\n    context: {\n      textTrackSegmentLoaderActor: ReadonlySignal<SegmentLoadingContext['textTrackSegmentLoaderActor']>;\n    };\n    config?: object;\n  }) =>\n    setupSegmentLoading({\n      state,\n      context,\n      config: { ...TEXT_SEGMENT_LOADING_CONFIG, ...config },\n    }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8HA,SAAS,oBAIP,EACA,OACA,SACA,UAa+D;CAC/D,MAAM,EAAE,aAAa,WAAW,sBAAsB;CACtD,MAAM,iBAAiB,OAAO,eAAe,kBAAkB,8BAA8B;CAE7F,MAAM,gBAAgB,eACpB,kBAAkB,MAAM,aAAa,KAAK,EAAE,MAAM,aAAa,KAAK,CAAC,CACtE;CAKD,MAAM,wBAAwB,eAAe;EAC3C,MAAM,QAAQ,cAAc,KAAK;AACjC,MAAI,CAAC,MAAO,QAAO,KAAA;AACnB,SAAO,oBAAoB,MAAM,YAAY,KAAK,IAAI,GAAG,MAAM,SAAS;GACxE;CAEF,MAAM,qBAAqB,eAAuC;AAChE,MAAI,CAAC,QAAQ,WAAW,KAAK,IAAI,CAAC,cAAc,KAAK,CAAE,QAAO;AAC9D,MAAI,MAAM,cAAc,KAAK,IAAI,MAAM,QAAQ,KAAK,KAAK,OAAQ,QAAO;AACxE,MAAI,MAAM,QAAQ,KAAK,KAAK,OAAQ,QAAO;AAC3C,SAAO;GACP;AAEF,QAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GACzB,SAAS,EAAE;GACX,iBAAiB,EAOf,aAAa;IACX,MAAM,QAAQ,cAAc,KAAK;AACjC,YAAQ,WAAW,KAAK,CAAE,KAAK;KAAE,MAAM;KAAQ;KAAO,CAAC;MAE1D;GACD,cAAc,EAIZ,eAAe;IACb,MAAM,QAAQ,cAAc,KAAK;AACjC,0BAAsB,KAAK;IAC3B,MAAM,cAAc,KAAK,MAAM,YAAY,IAAI;AAC/C,SAAK,QAAQ,WAAW,CAAE,KAAK;KAC7B,MAAM;KACN;KACA,OAAO;MAAE,OAAO;MAAa,KAAK,cAAc;MAAgB;KACjE,CAAC;MAEL;GACF;EACF,CAAC;;AAOJ,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;CACpB;AAED,MAAM,+BAA+B;CACnC,GAAG;CACH,mBAAmB;CACpB;AAED,MAAM,8BAA8B;CAClC,GAAG;CACH,mBAAmB;CACpB;AAMD,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAuB;CAC9F,aAAa,CAAC,0BAA0B;CACxC,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;GAAQ;EACvD,CAAC;CACL,CAAC;AAEF,MAAa,oBAAoB,eAAe;CAC9C,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAuB;CAC9F,aAAa,CAAC,0BAA0B;CACxC,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA8B,GAAG;GAAQ;EACvD,CAAC;CACL,CAAC;AAEF,MAAa,wBAAwB,eAAe;CAClD,WAAW;EAAC;EAAgB;EAAW;EAAe;EAAiB;EAAsB;CAC7F,aAAa,CAAC,8BAA8B;CAC5C,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAQX,oBAAoB;EAClB;EACA;EACA,QAAQ;GAAE,GAAG;GAA6B,GAAG;GAAQ;EACtD,CAAC;CACL,CAAC"}

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

@@ -0,0 +1,173 @@
+import { computed } from "../../../core/signals/primitives.js";
+import { defineBehavior } from "../../../core/composition/create-composition.js";
+import { createMachineReactor } from "../../../core/reactors/create-machine-reactor.js";
+import { hasCodecs } from "../../../media/utils/tracks.js";
+import { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from "../track-types.js";
+import { getSelectedTrack } from "../../../media/utils/track-selection.js";
+import { buildMimeCodec, createSourceBuffer } from "../../../media/dom/mse/mediasource-setup.js";
+import { createTrackedFetch, fetchStream } from "../../../network/fetch.js";
+import { createSegmentLoaderActor } from "../../actors/dom/segment-loader.js";
+import { createSourceBufferActor } from "../../actors/dom/source-buffer.js";
+//#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 `switchVideoQuality`
+*    (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 } = 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 bufferActor = createSourceBufferActor(createSourceBuffer(context.mediaSource.get(), buildMimeCodec(getSelectedTrack({
+					presentation: state.presentation.get(),
+					[selectedKey]: state[selectedKey].get()
+				}, type))));
+				const segmentLoader = createSegmentLoaderActor(bufferActor, fetch, {
+					forwardBuffer,
+					backBuffer
+				});
+				context[actorKey].set(bufferActor);
+				context[loaderKey].set(segmentLoader);
+				return () => {
+					segmentLoader.destroy();
+					bufferActor.destroy();
+					context[loaderKey].set(void 0);
+					context[actorKey].set(void 0);
+				};
+			} }
+		}
+	});
+}
+/**
+* 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));
+		return setupBufferActors({
+			state,
+			context,
+			config: {
+				...VIDEO_TYPE_CONFIG,
+				fetch: trackedFetch,
+				...config
+			}
+		});
+	}
+});
+/**
+* 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.
+*/
+const setupAudioBufferActors = defineBehavior({
+	stateKeys: ["presentation", "selectedAudioTrackId"],
+	contextKeys: [
+		"mediaSource",
+		"audioBufferActor",
+		"audioSegmentLoaderActor"
+	],
+	setup: ({ state, context, config = {} }) => setupBufferActors({
+		state,
+		context,
+		config: {
+			...AUDIO_TYPE_CONFIG,
+			fetch: fetchStream,
+			...config
+		}
+	})
+});
+//#endregion
+export { setupAudioBufferActors, setupVideoBufferActors };
+
+//# sourceMappingURL=setup-buffer-actors.js.map

package/dist/default/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 `switchVideoQuality`\n *    (default video) both subscribe to `state.presentation` flipping to\n *    resolved; their effects run in the same `runPending` iteration and\n *    write `selectedAudioTrackId` + `selectedVideoTrackId` within it.\n * 2. **Self — both per-type monitors flip in one `runPending`.**\n *    After (1), both monitors re-evaluate and flip to `'buffer-ready'`\n *    in the next `runPending`. Both `entry` bodies run synchronously\n *    within that iteration — both `addSourceBuffer` calls land before\n *    the iteration ends.\n * 3. **Downstream — `appendBuffer` is async.** `loadVideoSegments` /\n *    `loadAudioSegments` read the per-type `xSegmentLoaderActor` slots;\n *    their effects fire in the *next* `runPending` and the actual\n *    `appendBuffer` requires a network round-trip via the\n *    `SegmentLoaderActor` — many microtasks past both `addSourceBuffer`\n *    calls.\n *\n * The cross-tick failure mode — a user-initiated audio track switch\n * *after* video segments have begun appending — is out of scope for\n * this behavior and would be addressed in the buffer/segment-loading\n * path via `changeType`-aware logic.\n *\n * # Sole writer\n *\n * `setupVideoBufferActors` is sole writer of `videoBufferActor` +\n * `videoSegmentLoaderActor` (and `bandwidthState` via its\n * trackedFetch); `setupAudioBufferActors` is sole writer of\n * `audioBufferActor` + `audioSegmentLoaderActor`. Both read\n * `mediaSource` from `setupMediaSource`. Downstream MSE behaviors\n * (`loadVideoSegments`, `loadAudioSegments`, `endOfStream`,\n * `updateMediaSourceDuration`) only read these slots.\n */\nimport { defineBehavior } from '../../../core/composition/create-composition';\nimport type { Reactor } from '../../../core/reactors/create-machine-reactor';\nimport { createMachineReactor } from '../../../core/reactors/create-machine-reactor';\nimport { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';\nimport { buildMimeCodec, createSourceBuffer } from '../../../media/dom/mse/mediasource-setup';\nimport type { MaybeResolvedPresentation, PartiallyResolvedTrack } from '../../../media/types';\nimport { getSelectedTrack, type TrackSelectionState } from '../../../media/utils/track-selection';\nimport { hasCodecs } from '../../../media/utils/tracks';\nimport type { BandwidthState } from '../../../network/bandwidth-estimator';\nimport { createTrackedFetch, type FetchBytes, fetchStream } from '../../../network/fetch';\nimport {\n  createSegmentLoaderActor,\n  type SegmentLoaderActor,\n  type SegmentLoaderActorConfig,\n} from '../../actors/dom/segment-loader';\nimport { createSourceBufferActor, type SourceBufferActor } from '../../actors/dom/source-buffer';\nimport { AUDIO_TYPE_CONFIG, VIDEO_TYPE_CONFIG } from '../track-types';\n\n/**\n * Media track type for MSE buffer setup.\n * Text tracks are excluded as they don't use MSE SourceBuffers.\n */\nexport type MediaTrackType = 'video' | 'audio';\n\nexport interface BufferActorsState {\n  presentation?: MaybeResolvedPresentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n  bandwidthState?: BandwidthState;\n}\n\nexport interface BufferActorsContext {\n  mediaSource?: MediaSource;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n  videoSegmentLoaderActor?: SegmentLoaderActor;\n  audioSegmentLoaderActor?: SegmentLoaderActor;\n}\n\ntype BufferActorsFsmState = 'preconditions-unmet' | 'buffer-ready';\n\ntype SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId';\ntype BufferActorKey = 'videoBufferActor' | 'audioBufferActor';\ntype SegmentLoaderActorKey = 'videoSegmentLoaderActor' | 'audioSegmentLoaderActor';\n\ntype BufferActorsStateMap<K extends SelectedTrackKey> = {\n  presentation: ReadonlySignal<BufferActorsState['presentation']>;\n} & { [P in K]: ReadonlySignal<BufferActorsState[P]> };\n\ntype BufferActorsContextMap<A extends BufferActorKey, L extends SegmentLoaderActorKey> = {\n  mediaSource: ReadonlySignal<BufferActorsContext['mediaSource']>;\n} & { [P in A]: Signal<SourceBufferActor | undefined> } & {\n  [P in L]: Signal<SegmentLoaderActor | undefined>;\n};\n\n// ============================================================================\n// Specialization helper\n//\n// `setupBufferActors` has the same shape as a Behavior `setup` function:\n// `({ state, context, config }) => reactor`. Each `setupXBufferActors`\n// export below calls it from inside its own `defineBehavior` setup,\n// passing its narrowed `state` / `context` through directly and supplying\n// the per-type `selectedKey`, `actorKey`, `loaderKey`, `type` discriminator,\n// and `fetch` inline.\n//\n// Gating is per-type only: no cross-type coupling. See the file-level\n// JSDoc for how the Firefox `mozHasAudio` invariant survives the split\n// via SPF's effect coalescing.\n// ============================================================================\n\nfunction setupBufferActors<K extends SelectedTrackKey, A extends BufferActorKey, L extends SegmentLoaderActorKey>({\n  state,\n  context,\n  config,\n}: {\n  state: BufferActorsStateMap<K>;\n  context: BufferActorsContextMap<A, L>;\n  config: {\n    type: MediaTrackType;\n    selectedKey: K;\n    actorKey: A;\n    loaderKey: L;\n    fetch: FetchBytes;\n  } & SegmentLoaderActorConfig;\n}): Reactor<BufferActorsFsmState | 'destroying' | 'destroyed'> {\n  const { type, selectedKey, actorKey, loaderKey, fetch, forwardBuffer, backBuffer } = config;\n  const derivedStateSignal = computed<BufferActorsFsmState>(() => {\n    if (!context.mediaSource.get()) return 'preconditions-unmet';\n    const selection: TrackSelectionState = {\n      presentation: state.presentation.get(),\n      [selectedKey]: state[selectedKey].get(),\n    };\n    return hasCodecs(getSelectedTrack(selection, type)) ? 'buffer-ready' : 'preconditions-unmet';\n  });\n\n  return createMachineReactor<BufferActorsFsmState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {},\n\n      'buffer-ready': {\n        entry: () => {\n          const mediaSource = context.mediaSource.get()!;\n          const selection: TrackSelectionState = {\n            presentation: state.presentation.get(),\n            [selectedKey]: state[selectedKey].get(),\n          };\n          const track = getSelectedTrack(selection, type) as PartiallyResolvedTrack;\n          const buffer = createSourceBuffer(mediaSource, buildMimeCodec(track));\n          const bufferActor = createSourceBufferActor(buffer);\n          const segmentLoader = createSegmentLoaderActor(bufferActor, fetch, { forwardBuffer, backBuffer });\n\n          // Synchronous slot writes — load-bearing for the Firefox\n          // `mozHasAudio` invariant (see file-level JSDoc). Both per-type\n          // entries' `addSourceBuffer` calls must land in the same\n          // `runPending` iteration; synchronous writes keep the contiguous\n          // JS frame. Downstream `loadXSegments` effects fire in the\n          // *next* `runPending`.\n          context[actorKey].set(bufferActor);\n          context[loaderKey].set(segmentLoader);\n\n          // State-exit cleanup — fires when `mediaSource` detaches, the\n          // selection unsets, or the behavior is destroyed. Destroy the\n          // loader before its upstream buffer-actor so any in-flight\n          // `appendBuffer` is aborted before the buffer-actor's own\n          // teardown.\n          return () => {\n            segmentLoader.destroy();\n            bufferActor.destroy();\n            context[loaderKey].set(undefined);\n            context[actorKey].set(undefined);\n          };\n        },\n      },\n    },\n  });\n}\n\n// ============================================================================\n// Specialized exports — one per media type\n// ============================================================================\n\n/**\n * Set up the video `SourceBufferActor` + `SegmentLoaderActor`. Fires\n * when `mediaSource` is attached and the selected video track is\n * present in the presentation with codecs. Gates only on video state —\n * no cross-type coupling. Owns a bandwidth-sampling `trackedFetch` and\n * is sole writer of `state.bandwidthState`.\n */\nexport const setupVideoBufferActors = defineBehavior({\n  stateKeys: ['presentation', 'selectedVideoTrackId', 'bandwidthState'] as const,\n  contextKeys: ['mediaSource', 'videoBufferActor', 'videoSegmentLoaderActor'] as const,\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: BufferActorsStateMap<'selectedVideoTrackId'> & {\n      bandwidthState: Signal<BufferActorsState['bandwidthState']>;\n    };\n    context: BufferActorsContextMap<'videoBufferActor', 'videoSegmentLoaderActor'>;\n    config?: object;\n  }) => {\n    // Bandwidth-sampling fetch. The factory accumulates EWMA state\n    // internally; the callback bridges samples to engine state for ABR.\n    // Created once at behavior setup time so the EWMA accumulates across\n    // source resets (each per-source loader-actor receives the same\n    // tracked fetch when reconstructed in `buffer-ready` entry).\n    const trackedFetch = createTrackedFetch(\n      state.bandwidthState.get() ?? {\n        fastEstimate: 0,\n        fastTotalWeight: 0,\n        slowEstimate: 0,\n        slowTotalWeight: 0,\n        bytesSampled: 0,\n      },\n      (next) => state.bandwidthState.set(next)\n    );\n    return setupBufferActors({\n      state,\n      context,\n      config: { ...VIDEO_TYPE_CONFIG, fetch: trackedFetch, ...config },\n    });\n  },\n});\n\n/**\n * Set up the audio `SourceBufferActor` + `SegmentLoaderActor`. Same\n * shape as `setupVideoBufferActors`, narrowed to audio. Today supplies\n * a non-sampling `fetchStream` (no audio ABR); adding audio ABR is a\n * localized change to this setup body (swap `fetchStream` for a\n * `createTrackedFetch` call + declare `bandwidthState` writable here)\n * without touching the shared helper.\n */\nexport const setupAudioBufferActors = defineBehavior({\n  stateKeys: ['presentation', 'selectedAudioTrackId'] as const,\n  contextKeys: ['mediaSource', 'audioBufferActor', 'audioSegmentLoaderActor'] as const,\n  setup: ({\n    state,\n    context,\n    config = {},\n  }: {\n    state: BufferActorsStateMap<'selectedAudioTrackId'>;\n    context: BufferActorsContextMap<'audioBufferActor', 'audioSegmentLoaderActor'>;\n    config?: object;\n  }) =>\n    setupBufferActors({\n      state,\n      context,\n      config: { ...AUDIO_TYPE_CONFIG, fetch: fetchStream, ...config },\n    }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmIA,SAAS,kBAAyG,EAChH,OACA,SACA,UAW6D;CAC7D,MAAM,EAAE,MAAM,aAAa,UAAU,WAAW,OAAO,eAAe,eAAe;CACrF,MAAM,qBAAqB,eAAqC;AAC9D,MAAI,CAAC,QAAQ,YAAY,KAAK,CAAE,QAAO;AAKvC,SAAO,UAAU,iBAJsB;GACrC,cAAc,MAAM,aAAa,KAAK;IACrC,cAAc,MAAM,aAAa,KAAK;GACxC,EAC4C,KAAK,CAAC,GAAG,iBAAiB;GACvE;AAEF,QAAO,qBAA2C;EAChD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAAE;GAEzB,gBAAgB,EACd,aAAa;IAQX,MAAM,cAAc,wBADL,mBANK,QAAQ,YAAY,KAAK,EAME,eADjC,iBAJyB;KACrC,cAAc,MAAM,aAAa,KAAK;MACrC,cAAc,MAAM,aAAa,KAAK;KACxC,EACyC,KAAK,CACqB,CAAC,CAClB;IACnD,MAAM,gBAAgB,yBAAyB,aAAa,OAAO;KAAE;KAAe;KAAY,CAAC;AAQjG,YAAQ,UAAU,IAAI,YAAY;AAClC,YAAQ,WAAW,IAAI,cAAc;AAOrC,iBAAa;AACX,mBAAc,SAAS;AACvB,iBAAY,SAAS;AACrB,aAAQ,WAAW,IAAI,KAAA,EAAU;AACjC,aAAQ,UAAU,IAAI,KAAA,EAAU;;MAGrC;GACF;EACF,CAAC;;;;;;;;;AAcJ,MAAa,yBAAyB,eAAe;CACnD,WAAW;EAAC;EAAgB;EAAwB;EAAiB;CACrE,aAAa;EAAC;EAAe;EAAoB;EAA0B;CAC3E,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAOP;EAMJ,MAAM,eAAe,mBACnB,MAAM,eAAe,KAAK,IAAI;GAC5B,cAAc;GACd,iBAAiB;GACjB,cAAc;GACd,iBAAiB;GACjB,cAAc;GACf,GACA,SAAS,MAAM,eAAe,IAAI,KAAK,CACzC;AACD,SAAO,kBAAkB;GACvB;GACA;GACA,QAAQ;IAAE,GAAG;IAAmB,OAAO;IAAc,GAAG;IAAQ;GACjE,CAAC;;CAEL,CAAC;;;;;;;;;AAUF,MAAa,yBAAyB,eAAe;CACnD,WAAW,CAAC,gBAAgB,uBAAuB;CACnD,aAAa;EAAC;EAAe;EAAoB;EAA0B;CAC3E,QAAQ,EACN,OACA,SACA,SAAS,EAAE,OAMX,kBAAkB;EAChB;EACA;EACA,QAAQ;GAAE,GAAG;GAAmB,OAAO;GAAa,GAAG;GAAQ;EAChE,CAAC;CACL,CAAC"}