@videojs/spf 10.0.0-beta.2 → 10.0.0-beta.21

package/dist/dev/dom/features/load-text-track-cues.js

@@ -0,0 +1,104 @@
+import { computed, untrack, update } from "../../core/signals/primitives.js";
+import { isResolvedTrack } from "../../core/types/index.js";
+import { createMachineReactor } from "../../core/create-machine-reactor.js";
+import { createTextTrackSegmentLoaderActor } from "./text-track-segment-loader-actor.js";
+import { createTextTracksActor } from "./text-tracks-actor.js";
+//#region src/dom/features/load-text-track-cues.ts
+function getTextTracks(presentation) {
+	return presentation?.selectionSets?.find((s) => s.type === "text")?.switchingSets[0]?.tracks;
+}
+function findSelectedTrack(state) {
+	const track = getTextTracks(state.presentation)?.find((t) => t.id === state.selectedTextTrackId);
+	return track && isResolvedTrack(track) ? track : void 0;
+}
+/**
+* Derives the correct state from current state and owners.
+*
+* States are mutually exclusive and exhaustive:
+* - `'preconditions-unmet'`: no mediaElement, or no resolved presentation with text tracks
+* - `'setting-up'`:          preconditions met; actors not yet in owners
+* - `'pending'`:             actors alive; no selection, or selected track not yet resolved/in DOM
+* - `'monitoring-for-loads'`: selected track resolved, in DOM — ready to dispatch load messages
+*/
+function deriveState(state, owners) {
+	if (!owners.mediaElement || !getTextTracks(state.presentation)?.length) return "preconditions-unmet";
+	if (!owners.textTracksActor || !owners.segmentLoaderActor) return "setting-up";
+	const track = findSelectedTrack(state);
+	if (!track || track.segments.length === 0) return "pending";
+	if (!Array.from(owners.mediaElement.textTracks).some((t) => t.id === state.selectedTextTrackId)) return "pending";
+	return "monitoring-for-loads";
+}
+function teardownActors(owners) {
+	const { textTracksActor, segmentLoaderActor } = untrack(() => owners.get());
+	if (!textTracksActor && !segmentLoaderActor) return;
+	textTracksActor?.destroy();
+	segmentLoaderActor?.destroy();
+	update(owners, {
+		textTracksActor: void 0,
+		segmentLoaderActor: void 0
+	});
+}
+/**
+* Text track cue loading orchestration.
+*
+* A single `always` monitor keeps the reactor in sync with conditions.
+* Actor lifecycle is managed across two states:
+*
+* - **`'setting-up'`** — creates `TextTracksActor` and `TextTrackSegmentLoaderActor`
+*   and writes them to owners. Entry resets any stale actors first.
+* - **`'preconditions-unmet'`** — destroys any actors in owners and resets them to
+*   `undefined`. Handles all paths back from active states.
+* - **`'monitoring-for-loads'`** — reactive dispatch: re-runs whenever `state`
+*   changes (selection, currentTime, presentation) and sends a `load` message to
+*   the segment loader.
+*
+* **Destroy note:** actors written to owners are NOT auto-destroyed when
+* `reactor.destroy()` is called. Callers must read them from owners and destroy
+* them explicitly alongside the reactor.
+*
+* @example
+* const reactor = loadTextTrackCues({ state, owners });
+* // later:
+* const { textTracksActor, segmentLoaderActor } = owners.get();
+* textTracksActor?.destroy();
+* segmentLoaderActor?.destroy();
+* reactor.destroy();
+*/
+function loadTextTrackCues({ state, owners }) {
+	const derivedStateSignal = computed(() => deriveState(state.get(), owners.get()));
+	const currentTimeSignal = computed(() => state.get().currentTime ?? 0);
+	const selectedTrackSignal = computed(() => findSelectedTrack(state.get()));
+	return createMachineReactor({
+		initial: "preconditions-unmet",
+		monitor: () => derivedStateSignal.get(),
+		states: {
+			"preconditions-unmet": { entry: () => {
+				teardownActors(owners);
+			} },
+			"setting-up": { entry: () => {
+				teardownActors(owners);
+				const mediaElement = owners.get().mediaElement;
+				const textTracksActor = createTextTracksActor(mediaElement);
+				update(owners, {
+					textTracksActor,
+					segmentLoaderActor: createTextTrackSegmentLoaderActor(textTracksActor)
+				});
+			} },
+			pending: {},
+			"monitoring-for-loads": { effects: () => {
+				const currentTime = currentTimeSignal.get();
+				const track = selectedTrackSignal.get();
+				const { segmentLoaderActor } = untrack(() => owners.get());
+				segmentLoaderActor.send({
+					type: "load",
+					track,
+					currentTime
+				});
+			} }
+		}
+	});
+}
+//#endregion
+export { loadTextTrackCues };
+
+//# sourceMappingURL=load-text-track-cues.js.map

package/dist/dev/dom/features/load-text-track-cues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-text-track-cues.js","names":[],"sources":["../../../../src/dom/features/load-text-track-cues.ts"],"sourcesContent":["import type { Reactor } from '../../core/create-machine-reactor';\nimport { createMachineReactor } from '../../core/create-machine-reactor';\nimport { computed, type Signal, untrack, update } from '../../core/signals/primitives';\nimport type { Presentation, TextTrack } from '../../core/types';\nimport { isResolvedTrack } from '../../core/types';\nimport type { TextTrackSegmentLoaderActor } from './text-track-segment-loader-actor';\nimport { createTextTrackSegmentLoaderActor } from './text-track-segment-loader-actor';\nimport type { TextTracksActor } from './text-tracks-actor';\nimport { createTextTracksActor } from './text-tracks-actor';\n\n/**\n * FSM states for text track cue loading.\n *\n * ```\n * 'preconditions-unmet' ── mediaElement + presentation + text tracks ──→ 'setting-up'\n *        ↑                                                                      |\n *        │                                                             actors created\n *        │                                                             in owners\n *        │                                                                      ↓\n *        ├───────────────── preconditions lost ─────────────────────── 'pending'\n *        │                                                                      |\n *        │                                                  selectedTrack resolved + in DOM\n *        │                                                                      ↓\n *        └───────────────── preconditions lost ──────────── 'monitoring-for-loads'\n *\n * any state ──── destroy() ────→ 'destroying' ────→ 'destroyed'\n * ```\n */\nexport type LoadTextTrackCuesState = 'preconditions-unmet' | 'setting-up' | 'pending' | 'monitoring-for-loads';\n\n/**\n * State shape for text track cue loading.\n */\nexport interface TextTrackCueLoadingState {\n  selectedTextTrackId?: string;\n  presentation?: Presentation;\n  /** Current playback position — used to gate VTT segment fetching to the forward buffer window. */\n  currentTime?: number;\n}\n\n/**\n * Owners shape for text track cue loading.\n *\n * `textTracksActor` and `segmentLoaderActor` are managed by this reactor:\n * written to owners in `'setting-up'` and reset to `undefined` on entry to\n * `'preconditions-unmet'` or `'setting-up'`. Callers are responsible for\n * destroying them when the reactor itself is destroyed (actors are not\n * auto-cleaned on `destroy()` — read them from owners and destroy explicitly).\n */\nexport interface TextTrackCueLoadingOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n  textTracksActor?: TextTracksActor | undefined;\n  segmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;\n}\n\n// ============================================================================\n// Helpers\n// ============================================================================\n\nfunction getTextTracks(presentation: Presentation | undefined) {\n  return presentation?.selectionSets?.find((s) => s.type === 'text')?.switchingSets[0]?.tracks;\n}\n\nfunction findSelectedTrack(state: TextTrackCueLoadingState): TextTrack | undefined {\n  const track = getTextTracks(state.presentation)?.find((t) => t.id === state.selectedTextTrackId);\n  return track && isResolvedTrack(track) ? track : undefined;\n}\n\n/**\n * Derives the correct state from current state and owners.\n *\n * States are mutually exclusive and exhaustive:\n * - `'preconditions-unmet'`: no mediaElement, or no resolved presentation with text tracks\n * - `'setting-up'`:          preconditions met; actors not yet in owners\n * - `'pending'`:             actors alive; no selection, or selected track not yet resolved/in DOM\n * - `'monitoring-for-loads'`: selected track resolved, in DOM — ready to dispatch load messages\n */\nfunction deriveState(state: TextTrackCueLoadingState, owners: TextTrackCueLoadingOwners): LoadTextTrackCuesState {\n  if (!owners.mediaElement || !getTextTracks(state.presentation)?.length) {\n    return 'preconditions-unmet';\n  }\n  if (!owners.textTracksActor || !owners.segmentLoaderActor) {\n    return 'setting-up';\n  }\n  const track = findSelectedTrack(state);\n  if (!track || track.segments.length === 0) return 'pending';\n  if (!Array.from(owners.mediaElement.textTracks).some((t) => t.id === state.selectedTextTrackId)) {\n    return 'pending';\n  }\n  return 'monitoring-for-loads';\n}\n\nfunction teardownActors(owners: Signal<TextTrackCueLoadingOwners>) {\n  const { textTracksActor, segmentLoaderActor } = untrack(() => owners.get());\n  // Only update owners if there are actors to clean up — avoids spurious\n  // signal writes on initial startup that would re-trigger other features.\n  if (!textTracksActor && !segmentLoaderActor) return;\n  textTracksActor?.destroy();\n  segmentLoaderActor?.destroy();\n  update(owners, { textTracksActor: undefined, segmentLoaderActor: undefined });\n}\n\n// ============================================================================\n// Main export\n// ============================================================================\n\n/**\n * Text track cue loading orchestration.\n *\n * A single `always` monitor keeps the reactor in sync with conditions.\n * Actor lifecycle is managed across two states:\n *\n * - **`'setting-up'`** — creates `TextTracksActor` and `TextTrackSegmentLoaderActor`\n *   and writes them to owners. Entry resets any stale actors first.\n * - **`'preconditions-unmet'`** — destroys any actors in owners and resets them to\n *   `undefined`. Handles all paths back from active states.\n * - **`'monitoring-for-loads'`** — reactive dispatch: re-runs whenever `state`\n *   changes (selection, currentTime, presentation) and sends a `load` message to\n *   the segment loader.\n *\n * **Destroy note:** actors written to owners are NOT auto-destroyed when\n * `reactor.destroy()` is called. Callers must read them from owners and destroy\n * them explicitly alongside the reactor.\n *\n * @example\n * const reactor = loadTextTrackCues({ state, owners });\n * // later:\n * const { textTracksActor, segmentLoaderActor } = owners.get();\n * textTracksActor?.destroy();\n * segmentLoaderActor?.destroy();\n * reactor.destroy();\n */\nexport function loadTextTrackCues<S extends TextTrackCueLoadingState, O extends TextTrackCueLoadingOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): Reactor<LoadTextTrackCuesState | 'destroying' | 'destroyed'> {\n  const derivedStateSignal = computed(() => deriveState(state.get(), owners.get()));\n  const currentTimeSignal = computed(() => state.get().currentTime ?? 0);\n  const selectedTrackSignal = computed(() => findSelectedTrack(state.get()));\n\n  return createMachineReactor<LoadTextTrackCuesState>({\n    initial: 'preconditions-unmet',\n    monitor: () => derivedStateSignal.get(),\n    states: {\n      'preconditions-unmet': {\n        // Entry: defensive actor reset on state entry (no-op if already undefined).\n        entry: () => {\n          teardownActors(owners);\n        },\n      },\n\n      'setting-up': {\n        // Entry: reset any stale actors, then create fresh ones and write to owners.\n        // The fn body is automatically untracked — no untrack() needed for mediaElement.\n        entry: () => {\n          teardownActors(owners);\n          const mediaElement = owners.get().mediaElement as HTMLMediaElement;\n          const textTracksActor = createTextTracksActor(mediaElement);\n          const segmentLoaderActor = createTextTrackSegmentLoaderActor(textTracksActor);\n          update(owners, { textTracksActor, segmentLoaderActor } as Partial<O>);\n        },\n      },\n\n      pending: {},\n\n      'monitoring-for-loads': {\n        // Reaction: re-runs whenever currentTime or selectedTrack changes, dispatching\n        // a load message to the segment loader. owners is read with untrack() since\n        // actor presence is guaranteed by deriveState when in this state.\n        effects: () => {\n          const currentTime = currentTimeSignal.get();\n          const track = selectedTrackSignal.get()!;\n          // deriveState guarantees segmentLoaderActor is in owners and findSelectedTrack\n          // returns a valid resolved track when in this state. The always monitor\n          // (registered before this effect) transitions us out before this re-runs\n          // if either invariant ever stops holding.\n          const { segmentLoaderActor } = untrack(() => owners.get());\n          segmentLoaderActor!.send({ type: 'load', track, currentTime });\n        },\n      },\n    },\n  });\n}\n"],"mappings":";;;;;;AA2DA,SAAS,cAAc,cAAwC;AAC7D,QAAO,cAAc,eAAe,MAAM,MAAM,EAAE,SAAS,OAAO,EAAE,cAAc,IAAI;;AAGxF,SAAS,kBAAkB,OAAwD;CACjF,MAAM,QAAQ,cAAc,MAAM,aAAa,EAAE,MAAM,MAAM,EAAE,OAAO,MAAM,oBAAoB;AAChG,QAAO,SAAS,gBAAgB,MAAM,GAAG,QAAQ,KAAA;;;;;;;;;;;AAYnD,SAAS,YAAY,OAAiC,QAA2D;AAC/G,KAAI,CAAC,OAAO,gBAAgB,CAAC,cAAc,MAAM,aAAa,EAAE,OAC9D,QAAO;AAET,KAAI,CAAC,OAAO,mBAAmB,CAAC,OAAO,mBACrC,QAAO;CAET,MAAM,QAAQ,kBAAkB,MAAM;AACtC,KAAI,CAAC,SAAS,MAAM,SAAS,WAAW,EAAG,QAAO;AAClD,KAAI,CAAC,MAAM,KAAK,OAAO,aAAa,WAAW,CAAC,MAAM,MAAM,EAAE,OAAO,MAAM,oBAAoB,CAC7F,QAAO;AAET,QAAO;;AAGT,SAAS,eAAe,QAA2C;CACjE,MAAM,EAAE,iBAAiB,uBAAuB,cAAc,OAAO,KAAK,CAAC;AAG3E,KAAI,CAAC,mBAAmB,CAAC,mBAAoB;AAC7C,kBAAiB,SAAS;AAC1B,qBAAoB,SAAS;AAC7B,QAAO,QAAQ;EAAE,iBAAiB,KAAA;EAAW,oBAAoB,KAAA;EAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiC/E,SAAgB,kBAA2F,EACzG,OACA,UAI+D;CAC/D,MAAM,qBAAqB,eAAe,YAAY,MAAM,KAAK,EAAE,OAAO,KAAK,CAAC,CAAC;CACjF,MAAM,oBAAoB,eAAe,MAAM,KAAK,CAAC,eAAe,EAAE;CACtE,MAAM,sBAAsB,eAAe,kBAAkB,MAAM,KAAK,CAAC,CAAC;AAE1E,QAAO,qBAA6C;EAClD,SAAS;EACT,eAAe,mBAAmB,KAAK;EACvC,QAAQ;GACN,uBAAuB,EAErB,aAAa;AACX,mBAAe,OAAO;MAEzB;GAED,cAAc,EAGZ,aAAa;AACX,mBAAe,OAAO;IACtB,MAAM,eAAe,OAAO,KAAK,CAAC;IAClC,MAAM,kBAAkB,sBAAsB,aAAa;AAE3D,WAAO,QAAQ;KAAE;KAAiB,oBADP,kCAAkC,gBAAgB;KACvB,CAAe;MAExE;GAED,SAAS,EAAE;GAEX,wBAAwB,EAItB,eAAe;IACb,MAAM,cAAc,kBAAkB,KAAK;IAC3C,MAAM,QAAQ,oBAAoB,KAAK;IAKvC,MAAM,EAAE,uBAAuB,cAAc,OAAO,KAAK,CAAC;AAC1D,uBAAoB,KAAK;KAAE,MAAM;KAAQ;KAAO;KAAa,CAAC;MAEjE;GACF;EACF,CAAC"}

package/dist/dev/dom/features/segment-loader-actor.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/dev/dom/features/segment-loader-actor.js

@@ -0,0 +1,243 @@
+import { calculateForwardFlushPoint, getSegmentsToLoad } from "../../core/buffer/forward-buffer.js";
+import { effect } from "../../core/signals/effect.js";
+import { calculateBackBufferFlushPoint } from "../../core/buffer/back-buffer.js";
+import { createMachineActor } from "../../core/create-machine-actor.js";
+import { SerialRunner, Task } from "../../core/task.js";
+//#region src/dom/features/segment-loader-actor.ts
+/**
+* Resolves when the SourceBufferActor snapshot reaches 'idle'.
+* Rejects if the signal is aborted or the actor is destroyed.
+*
+* Used to sequence SourceBufferActor operations without awaiting send()
+* directly — send() is fire-and-forget; callers observe completion via
+* state transition.
+*/
+function waitForIdle(snapshot, signal) {
+	return new Promise((resolve, reject) => {
+		if (snapshot.get().value === "idle") {
+			resolve();
+			return;
+		}
+		if (snapshot.get().value === "destroyed") {
+			reject(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		if (signal.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		let stop;
+		const cleanup = (fn) => {
+			stop?.();
+			signal.removeEventListener("abort", onAbort);
+			fn();
+		};
+		const onAbort = () => cleanup(() => reject(signal.reason));
+		stop = effect(() => {
+			const value = snapshot.get().value;
+			if (value === "idle") cleanup(resolve);
+			else if (value === "destroyed") cleanup(() => reject(new DOMException("Aborted", "AbortError")));
+		});
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Wraps a LoadTask descriptor into a Task that fetches (if needed) and
+* forwards to SourceBufferActor. Updates in-flight context around async
+* operations so the loading handler can make accurate continue/preempt
+* decisions at any point.
+*/
+function makeLoadTask(op, { getContext, setContext, fetchBytes, sourceBufferActor }) {
+	return new Task(async (taskSignal) => {
+		if (taskSignal.aborted) return;
+		if (op.type === "remove") {
+			sourceBufferActor.send(op);
+			await waitForIdle(sourceBufferActor.snapshot, taskSignal);
+			return;
+		}
+		if (op.type === "append-init") {
+			setContext({
+				...getContext(),
+				inFlightInitTrackId: op.meta.trackId
+			});
+			try {
+				const data = await fetchBytes(op, {
+					signal: taskSignal,
+					minChunkSize: Infinity
+				});
+				if (!taskSignal.aborted) {
+					sourceBufferActor.send({
+						type: "append-init",
+						data,
+						meta: op.meta
+					});
+					await waitForIdle(sourceBufferActor.snapshot, taskSignal);
+				}
+			} finally {
+				setContext({
+					...getContext(),
+					inFlightInitTrackId: null
+				});
+			}
+			return;
+		}
+		setContext({
+			...getContext(),
+			inFlightSegmentId: op.meta.id
+		});
+		try {
+			const stream = await fetchBytes(op, { signal: taskSignal });
+			if (!taskSignal.aborted) {
+				sourceBufferActor.send({
+					type: "append-segment",
+					data: stream,
+					meta: op.meta
+				});
+				await waitForIdle(sourceBufferActor.snapshot, taskSignal);
+			}
+		} finally {
+			setContext({
+				...getContext(),
+				inFlightSegmentId: null
+			});
+		}
+	});
+}
+/**
+* Creates a SegmentLoaderActor for one track type (video or audio).
+*
+* Receives load assignments via `send()` and owns all execution: planning,
+* removes, fetches, and appends. Coordinates with the SourceBufferActor for
+* all physical SourceBuffer operations.
+*
+* Planning (Cases 1–3) happens in the `load` handler on every incoming
+* message, producing an ordered LoadTask list. The runner drains that list
+* sequentially via SerialRunner. When a new message arrives mid-run, the
+* handler replans and either continues the in-flight operation (abortPending
+* + schedule new remainder) or preempts it (abortAll + cancel SourceBuffer
+* if needed + schedule new plan).
+*
+* @param sourceBufferActor - Shared SourceBufferActor reference (not owned)
+* @param fetchBytes - Tracked fetch closure (owns throughput sampling for segments).
+*   Accepts an optional `minChunkSize` in options; init segments pass `Infinity`
+*   so the entire body accumulates as one chunk before appending.
+*/
+function createSegmentLoaderActor(sourceBufferActor, fetchBytes) {
+	const getBufferedSegments = (allSegments) => {
+		const bufferedIds = new Set(sourceBufferActor.snapshot.get().context.segments.filter((s) => !s.partial).map((s) => s.id));
+		return allSegments.filter((s) => bufferedIds.has(s.id));
+	};
+	/**
+	* Translate a load message into an ordered LoadTask list based on committed
+	* actor state. In-flight awareness is handled separately in the load handler.
+	*
+	* @todo Rename alongside LoadTask (e.g. planOps).
+	*
+	* Case 1 — Removes: forward and back buffer flush points, segment-aligned.
+	*   No flush on track switch: appending new content overwrites existing buffer
+	*   ranges, and the actor's time-aligned deduplication keeps the segment model
+	*   accurate as new segments arrive.
+	*
+	* Case 2 — Init: schedule if not yet committed for this track.
+	*
+	* Case 3 — Segments: all segments in the load window not yet committed.
+	*/
+	const planTasks = (message) => {
+		const { track, range } = message;
+		const actorCtx = sourceBufferActor.snapshot.get().context;
+		const bufferedSegments = getBufferedSegments(track.segments);
+		const currentTime = range?.start ?? 0;
+		const tasks = [];
+		if (range) {
+			const forwardFlushStart = calculateForwardFlushPoint(bufferedSegments, currentTime);
+			if (forwardFlushStart < Infinity) tasks.push({
+				type: "remove",
+				start: forwardFlushStart,
+				end: Infinity
+			});
+			const backFlushEnd = calculateBackBufferFlushPoint(bufferedSegments, currentTime);
+			if (backFlushEnd > 0) tasks.push({
+				type: "remove",
+				start: 0,
+				end: backFlushEnd
+			});
+		}
+		if (actorCtx.initTrackId !== track.id) tasks.push({
+			type: "append-init",
+			meta: { trackId: track.id },
+			url: track.initialization.url,
+			...track.initialization.byteRange !== void 0 && { byteRange: track.initialization.byteRange }
+		});
+		if (range) {
+			const EPSILON = 1e-4;
+			const segmentsToLoad = getSegmentsToLoad(track.segments, bufferedSegments, currentTime).filter((seg) => {
+				const existing = actorCtx.segments.find((s) => Math.abs(s.startTime - seg.startTime) < EPSILON);
+				if (existing?.partial) return true;
+				if (!existing?.trackBandwidth || !track.bandwidth) return true;
+				return track.bandwidth > existing.trackBandwidth;
+			});
+			for (const segment of segmentsToLoad) tasks.push({
+				type: "append-segment",
+				meta: {
+					id: segment.id,
+					startTime: segment.startTime,
+					duration: segment.duration,
+					trackId: track.id,
+					trackBandwidth: track.bandwidth
+				},
+				url: segment.url,
+				...segment.byteRange !== void 0 && { byteRange: segment.byteRange }
+			});
+		}
+		return tasks;
+	};
+	const scheduleAll = (tasks, { getContext, setContext, runner }) => {
+		tasks.forEach((op) => {
+			runner.schedule(makeLoadTask(op, {
+				getContext,
+				setContext,
+				fetchBytes,
+				sourceBufferActor
+			})).then(void 0, (e) => {
+				if (e instanceof Error && e.name === "AbortError") return;
+				console.error("Unexpected error in segment loader:", e);
+				runner.abortPending();
+			});
+		});
+	};
+	return createMachineActor({
+		runner: () => new SerialRunner(),
+		initial: "idle",
+		context: {
+			inFlightInitTrackId: null,
+			inFlightSegmentId: null
+		},
+		states: {
+			idle: { on: { load: (msg, ctx) => {
+				const allTasks = planTasks(msg);
+				if (allTasks.length === 0) return;
+				ctx.transition("loading");
+				scheduleAll(allTasks, ctx);
+			} } },
+			loading: {
+				onSettled: "idle",
+				on: { load: (msg, ctx) => {
+					const { context, runner } = ctx;
+					const allTasks = planTasks(msg);
+					if (context.inFlightSegmentId !== null && allTasks.some((t) => t.type === "append-segment" && t.meta.id === context.inFlightSegmentId) || context.inFlightInitTrackId !== null && allTasks.some((t) => t.type === "append-init" && t.meta.trackId === context.inFlightInitTrackId)) {
+						runner.abortPending();
+						scheduleAll(allTasks.filter((t) => !(t.type === "append-segment" && t.meta.id === context.inFlightSegmentId) && !(t.type === "append-init" && t.meta.trackId === context.inFlightInitTrackId)), ctx);
+					} else {
+						runner.abortAll();
+						if (context.inFlightSegmentId !== null || context.inFlightInitTrackId !== null && allTasks.some((t) => t.type === "append-init" && t.meta.trackId !== context.inFlightInitTrackId)) sourceBufferActor.send({ type: "cancel" });
+						scheduleAll(allTasks, ctx);
+					}
+				} }
+			}
+		}
+	});
+}
+//#endregion
+export { createSegmentLoaderActor };
+
+//# sourceMappingURL=segment-loader-actor.js.map

package/dist/dev/dom/features/segment-loader-actor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-loader-actor.js","names":[],"sources":["../../../../src/dom/features/segment-loader-actor.ts"],"sourcesContent":["import { calculateBackBufferFlushPoint } from '../../core/buffer/back-buffer';\nimport { calculateForwardFlushPoint, getSegmentsToLoad } from '../../core/buffer/forward-buffer';\nimport { createMachineActor, type HandlerContext, type MessageActor } from '../../core/create-machine-actor';\nimport { effect } from '../../core/signals/effect';\nimport { SerialRunner, Task } from '../../core/task';\nimport type { AddressableObject, AudioTrack, Segment, VideoTrack } from '../../core/types';\nimport type {\n  AppendInitMessage,\n  AppendSegmentMessage,\n  RemoveMessage,\n  SourceBufferActor,\n} from '../media/source-buffer-actor';\n\n// ============================================================================\n// BUFFER STATE TYPES\n// ============================================================================\n\n/**\n * Buffer state for a single SourceBuffer.\n * Tracks which init segment and media segments are loaded.\n */\nexport interface SourceBufferState {\n  /** Track ID of the loaded init segment */\n  initTrackId?: string;\n  /** Loaded media segments (unordered - selectors derive ordering) */\n  segments: Array<{ id: string; trackId: string }>;\n}\n\n/**\n * Buffer state for all SourceBuffers.\n */\nexport interface BufferState {\n  video?: SourceBufferState;\n  audio?: SourceBufferState;\n}\n\n// ============================================================================\n// MESSAGE PROTOCOL\n// ============================================================================\n\n/** Track types that have SourceBuffers (video and audio only). */\nexport type SegmentLoaderTrack = VideoTrack | AudioTrack;\n\n/**\n * Message sent to a SegmentLoaderActor.\n *\n * `range` is optional to distinguish loading modes:\n * - No range: load init segment only (metadata preload mode)\n * - With range: load init + all segments overlapping [start, end]\n *\n * `start` and `end` are raw time values — no segment snapping.\n * The actor maps them onto segment boundaries internally.\n */\nexport type SegmentLoaderMessage = {\n  type: 'load';\n  track: SegmentLoaderTrack;\n  range?: { start: number; end: number };\n};\n\n// ============================================================================\n// LOAD TASK\n// ============================================================================\n\n/**\n * A LoadTask is the intent to perform one unit of SegmentLoader work.\n * Unlike SourceBufferMessage, fetch-based tasks carry a URL rather than\n * pre-fetched data — the runner fetches and appends them in sequence.\n *\n * Derived from SourceBufferMessage types by removing `data` and adding\n * a fetch URL via AddressableObject.\n *\n * @todo Rename — \"LoadTask\" risks confusion with the `Task` class used for\n * SourceBufferActor scheduling. These are closer to operation descriptors or\n * messages than tasks in that sense.\n */\nexport type LoadTask =\n  | (Omit<AppendInitMessage, 'data'> & AddressableObject)\n  | (Omit<AppendSegmentMessage, 'data'> & AddressableObject)\n  | RemoveMessage;\n\n// ============================================================================\n// ACTOR INTERFACE\n// ============================================================================\n\n/** Finite states of the actor. */\nexport type SegmentLoaderActorState = 'idle' | 'loading' | 'destroyed';\n\n/** Non-finite (extended) data managed by the actor. */\nexport interface SegmentLoaderActorContext {\n  /** Track ID of the init segment currently being fetched/appended, or null. */\n  inFlightInitTrackId: string | null;\n  /** Segment ID currently being fetched/appended, or null. */\n  inFlightSegmentId: string | null;\n}\n\nexport type SegmentLoaderActor = MessageActor<SegmentLoaderActorState, SegmentLoaderActorContext, SegmentLoaderMessage>;\n\n// ============================================================================\n// HELPERS\n// ============================================================================\n\ntype FetchBytes = (\n  addressable: AddressableObject,\n  options?: RequestInit & { minChunkSize?: number }\n) => Promise<AsyncIterable<Uint8Array>>;\n\n/**\n * Resolves when the SourceBufferActor snapshot reaches 'idle'.\n * Rejects if the signal is aborted or the actor is destroyed.\n *\n * Used to sequence SourceBufferActor operations without awaiting send()\n * directly — send() is fire-and-forget; callers observe completion via\n * state transition.\n */\nfunction waitForIdle(snapshot: SourceBufferActor['snapshot'], signal: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (snapshot.get().value === 'idle') {\n      resolve();\n      return;\n    }\n    if (snapshot.get().value === 'destroyed') {\n      reject(new DOMException('Aborted', 'AbortError'));\n      return;\n    }\n    if (signal.aborted) {\n      reject(signal.reason);\n      return;\n    }\n\n    let stop: (() => void) | undefined;\n\n    const cleanup = (fn: () => void) => {\n      stop?.();\n      signal.removeEventListener('abort', onAbort);\n      fn();\n    };\n\n    const onAbort = () => cleanup(() => reject(signal.reason));\n\n    stop = effect(() => {\n      const value = snapshot.get().value;\n      if (value === 'idle') cleanup(resolve);\n      else if (value === 'destroyed') cleanup(() => reject(new DOMException('Aborted', 'AbortError')));\n    });\n\n    signal.addEventListener('abort', onAbort, { once: true });\n  });\n}\n\n// ============================================================================\n// LOAD TASK FACTORY\n// ============================================================================\n\ninterface LoadTaskOptions {\n  getContext: () => SegmentLoaderActorContext;\n  setContext: (ctx: SegmentLoaderActorContext) => void;\n  fetchBytes: FetchBytes;\n  sourceBufferActor: SourceBufferActor;\n}\n\n/**\n * Wraps a LoadTask descriptor into a Task that fetches (if needed) and\n * forwards to SourceBufferActor. Updates in-flight context around async\n * operations so the loading handler can make accurate continue/preempt\n * decisions at any point.\n */\nfunction makeLoadTask(\n  op: LoadTask,\n  { getContext, setContext, fetchBytes, sourceBufferActor }: LoadTaskOptions\n): Task<void> {\n  return new Task(async (taskSignal) => {\n    if (taskSignal.aborted) return;\n\n    if (op.type === 'remove') {\n      sourceBufferActor.send(op);\n      await waitForIdle(sourceBufferActor.snapshot, taskSignal);\n      return;\n    }\n\n    if (op.type === 'append-init') {\n      setContext({ ...getContext(), inFlightInitTrackId: op.meta.trackId });\n      try {\n        // Init segments are small and need the full body before appending.\n        // minChunkSize: Infinity accumulates all chunks into one before yielding.\n        const data = await fetchBytes(op, { signal: taskSignal, minChunkSize: Infinity });\n        if (!taskSignal.aborted) {\n          sourceBufferActor.send({ type: 'append-init', data, meta: op.meta });\n          await waitForIdle(sourceBufferActor.snapshot, taskSignal);\n        }\n      } finally {\n        setContext({ ...getContext(), inFlightInitTrackId: null });\n      }\n      return;\n    }\n\n    // append-segment: await headers eagerly (starts the HTTP connection and\n    // records the fetch in observers like tests), then pass the body stream\n    // directly to the actor so chunks are appended as they arrive.\n    setContext({ ...getContext(), inFlightSegmentId: op.meta.id });\n    try {\n      const stream = await fetchBytes(op, { signal: taskSignal });\n      if (!taskSignal.aborted) {\n        sourceBufferActor.send({ type: 'append-segment', data: stream, meta: op.meta });\n        await waitForIdle(sourceBufferActor.snapshot, taskSignal);\n      }\n    } finally {\n      setContext({ ...getContext(), inFlightSegmentId: null });\n    }\n  });\n}\n\n// ============================================================================\n// IMPLEMENTATION\n// ============================================================================\n\n/**\n * Creates a SegmentLoaderActor for one track type (video or audio).\n *\n * Receives load assignments via `send()` and owns all execution: planning,\n * removes, fetches, and appends. Coordinates with the SourceBufferActor for\n * all physical SourceBuffer operations.\n *\n * Planning (Cases 1–3) happens in the `load` handler on every incoming\n * message, producing an ordered LoadTask list. The runner drains that list\n * sequentially via SerialRunner. When a new message arrives mid-run, the\n * handler replans and either continues the in-flight operation (abortPending\n * + schedule new remainder) or preempts it (abortAll + cancel SourceBuffer\n * if needed + schedule new plan).\n *\n * @param sourceBufferActor - Shared SourceBufferActor reference (not owned)\n * @param fetchBytes - Tracked fetch closure (owns throughput sampling for segments).\n *   Accepts an optional `minChunkSize` in options; init segments pass `Infinity`\n *   so the entire body accumulates as one chunk before appending.\n */\nexport function createSegmentLoaderActor(\n  sourceBufferActor: SourceBufferActor,\n  fetchBytes: FetchBytes\n): SegmentLoaderActor {\n  type UserState = Exclude<SegmentLoaderActorState, 'destroyed'>;\n  type Ctx = HandlerContext<UserState, SegmentLoaderActorContext, () => SerialRunner>;\n\n  const getBufferedSegments = (allSegments: readonly Segment[]): Segment[] => {\n    // Exclude partial segments — they are still being streamed and must not be\n    // treated as fully buffered for load planning or buffer window calculations.\n    const bufferedIds = new Set(\n      sourceBufferActor.snapshot\n        .get()\n        .context.segments.filter((s) => !s.partial)\n        .map((s) => s.id)\n    );\n    return allSegments.filter((s) => bufferedIds.has(s.id));\n  };\n\n  /**\n   * Translate a load message into an ordered LoadTask list based on committed\n   * actor state. In-flight awareness is handled separately in the load handler.\n   *\n   * @todo Rename alongside LoadTask (e.g. planOps).\n   *\n   * Case 1 — Removes: forward and back buffer flush points, segment-aligned.\n   *   No flush on track switch: appending new content overwrites existing buffer\n   *   ranges, and the actor's time-aligned deduplication keeps the segment model\n   *   accurate as new segments arrive.\n   *\n   * Case 2 — Init: schedule if not yet committed for this track.\n   *\n   * Case 3 — Segments: all segments in the load window not yet committed.\n   */\n  const planTasks = (message: SegmentLoaderMessage): LoadTask[] => {\n    const { track, range } = message;\n    const actorCtx = sourceBufferActor.snapshot.get().context;\n    const bufferedSegments = getBufferedSegments(track.segments);\n    const currentTime = range?.start ?? 0;\n    const tasks: LoadTask[] = [];\n\n    // Case 1: Removes\n    if (range) {\n      const forwardFlushStart = calculateForwardFlushPoint(bufferedSegments, currentTime);\n      if (forwardFlushStart < Infinity) {\n        tasks.push({ type: 'remove', start: forwardFlushStart, end: Infinity });\n      }\n      const backFlushEnd = calculateBackBufferFlushPoint(bufferedSegments, currentTime);\n      if (backFlushEnd > 0) {\n        tasks.push({ type: 'remove', start: 0, end: backFlushEnd });\n      }\n    }\n\n    // Case 2: Init\n    if (actorCtx.initTrackId !== track.id) {\n      tasks.push({\n        type: 'append-init',\n        meta: { trackId: track.id },\n        url: track.initialization.url,\n        ...(track.initialization.byteRange !== undefined && { byteRange: track.initialization.byteRange }),\n      });\n    }\n\n    // Case 3: Segments\n    if (range) {\n      const EPSILON = 0.0001;\n      const segmentsToLoad = getSegmentsToLoad(track.segments, bufferedSegments, currentTime).filter((seg) => {\n        // Quality-aware filter: skip segments already covered by equal-or-higher-quality\n        // content in the actor context. Preserves buffered high-quality content during\n        // ABR downgrades; loads during upgrades and for uncovered positions.\n        const existing = actorCtx.segments.find((s) => Math.abs(s.startTime - seg.startTime) < EPSILON);\n        // Partial segments are still streaming — treat as not buffered so they\n        // are always re-planned (avoids relying on incomplete data).\n        if (existing?.partial) return true;\n        if (!existing?.trackBandwidth || !track.bandwidth) return true;\n        return track.bandwidth > existing.trackBandwidth;\n      });\n      for (const segment of segmentsToLoad) {\n        tasks.push({\n          type: 'append-segment',\n          meta: {\n            id: segment.id,\n            startTime: segment.startTime,\n            duration: segment.duration,\n            trackId: track.id,\n            trackBandwidth: track.bandwidth,\n          },\n          url: segment.url,\n          ...(segment.byteRange !== undefined && { byteRange: segment.byteRange }),\n        });\n      }\n    }\n\n    return tasks;\n  };\n\n  const scheduleAll = (tasks: LoadTask[], { getContext, setContext, runner }: Ctx): void => {\n    tasks.forEach((op) => {\n      runner\n        .schedule(makeLoadTask(op, { getContext, setContext, fetchBytes, sourceBufferActor }))\n        .then(undefined, (e: unknown) => {\n          if (e instanceof Error && e.name === 'AbortError') return;\n          // On unexpected fetch/append errors, abort remaining tasks so a failed\n          // init doesn't cause segment fetches to proceed with no init segment.\n          console.error('Unexpected error in segment loader:', e);\n          runner.abortPending();\n        });\n    });\n  };\n\n  return createMachineActor<UserState, SegmentLoaderActorContext, SegmentLoaderMessage, () => SerialRunner>({\n    runner: () => new SerialRunner(),\n    initial: 'idle',\n    context: { inFlightInitTrackId: null, inFlightSegmentId: null },\n    states: {\n      idle: {\n        on: {\n          load: (msg, ctx) => {\n            const allTasks = planTasks(msg);\n            if (allTasks.length === 0) return;\n            ctx.transition('loading');\n            scheduleAll(allTasks, ctx);\n          },\n        },\n      },\n      loading: {\n        onSettled: 'idle',\n        on: {\n          load: (msg, ctx) => {\n            const { context, runner } = ctx;\n            const allTasks = planTasks(msg);\n\n            // Determine whether the in-flight operation is still needed.\n            const inFlightStillNeeded =\n              (context.inFlightSegmentId !== null &&\n                allTasks.some((t) => t.type === 'append-segment' && t.meta.id === context.inFlightSegmentId)) ||\n              (context.inFlightInitTrackId !== null &&\n                allTasks.some((t) => t.type === 'append-init' && t.meta.trackId === context.inFlightInitTrackId));\n\n            if (inFlightStillNeeded) {\n              // Continue: abort only the pending queue, let the in-flight task finish.\n              // Schedule everything except the in-flight item — it covers that slot.\n              runner.abortPending();\n              scheduleAll(\n                allTasks.filter(\n                  (t) =>\n                    !(t.type === 'append-segment' && t.meta.id === context.inFlightSegmentId) &&\n                    !(t.type === 'append-init' && t.meta.trackId === context.inFlightInitTrackId)\n                ),\n                ctx\n              );\n            } else {\n              // Preempt: abort everything and replan.\n              runner.abortAll();\n              // Cancel SourceBufferActor tasks when a segment is in-flight (always\n              // discard) or when a track switch is happening (new track's init follows).\n              // For a same-track seek with an in-flight init, skip cancel — the task's\n              // signal is not aborted (abortAll was called on the runner, but the init\n              // task already completed or will complete via its own signal path).\n              const cancelSourceBuffer =\n                context.inFlightSegmentId !== null ||\n                (context.inFlightInitTrackId !== null &&\n                  allTasks.some((t) => t.type === 'append-init' && t.meta.trackId !== context.inFlightInitTrackId));\n              if (cancelSourceBuffer) {\n                sourceBufferActor.send({ type: 'cancel' });\n              }\n              scheduleAll(allTasks, ctx);\n            }\n          },\n        },\n      },\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/dev/dom/features/setup-mediasource.js

@@ -0,0 +1,48 @@
+import { effect } from "../../core/signals/effect.js";
+import { computed } from "../../core/signals/primitives.js";
+import { attachMediaSource, createMediaSource, observeMediaSourceReadyState } from "../media/mediasource-setup.js";
+//#region src/dom/features/setup-mediasource.ts
+/**
+* Setup MediaSource orchestration.
+*
+* Creates and attaches MediaSource when:
+* - mediaElement exists in owners
+* - presentation.url exists in state
+*
+* Updates owners.mediaSource after successful setup.
+*/
+function setupMediaSource({ state, owners }) {
+	const abortController = new AbortController();
+	const mediaElementSignal = computed(() => owners.get().mediaElement);
+	const presentationUrlSignal = computed(() => state.get().presentation?.url);
+	const canSetupSignal = computed(() => !!mediaElementSignal.get() && !!presentationUrlSignal.get());
+	const mediaElementSrcSignal = computed(() => mediaElementSignal.get()?.src);
+	const mediaSourceSignal = computed(() => owners.get().mediaSource);
+	const shouldSetupSignal = computed(() => !mediaElementSrcSignal.get());
+	const cleanupEffect = effect(() => {
+		if (!canSetupSignal.get() || !shouldSetupSignal.get()) return;
+		const mediaElement = mediaElementSignal.get();
+		const { signal } = abortController;
+		const mediaSource = createMediaSource({ preferManaged: true });
+		const mediaSourceReadyState = observeMediaSourceReadyState(mediaSource, signal);
+		attachMediaSource(mediaSource, mediaElement);
+		const cleanupOwnersUpdateEffect = effect(() => {
+			if (!!mediaSourceSignal.get() || mediaSourceReadyState.get() !== "open") return;
+			owners.set(Object.assign({}, owners.get(), {
+				mediaSource,
+				mediaSourceReadyState
+			}));
+		});
+		return () => {
+			cleanupOwnersUpdateEffect();
+		};
+	});
+	return () => {
+		abortController?.abort();
+		cleanupEffect();
+	};
+}
+//#endregion
+export { setupMediaSource };
+
+//# sourceMappingURL=setup-mediasource.js.map

package/dist/dev/dom/features/setup-mediasource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-mediasource.js","names":[],"sources":["../../../../src/dom/features/setup-mediasource.ts"],"sourcesContent":["import { effect } from '../../core/signals/effect';\nimport { computed, type ReadonlySignal, type Signal } from '../../core/signals/primitives';\nimport type { Presentation } from '../../core/types';\nimport { attachMediaSource, createMediaSource, observeMediaSourceReadyState } from '../media/mediasource-setup';\n\n/**\n * State shape required for MediaSource setup.\n */\nexport interface MediaSourceState {\n  presentation?: Presentation;\n}\n\n/**\n * Owners shape for MediaSource setup.\n */\nexport interface MediaSourceOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n  mediaSource?: MediaSource;\n  /** Reactive mirror of `mediaSource.readyState` — updated via DOM events. */\n  mediaSourceReadyState?: ReadonlySignal<MediaSource['readyState']>;\n}\n\n/**\n * Setup MediaSource orchestration.\n *\n * Creates and attaches MediaSource when:\n * - mediaElement exists in owners\n * - presentation.url exists in state\n *\n * Updates owners.mediaSource after successful setup.\n */\nexport function setupMediaSource<S extends MediaSourceState, O extends MediaSourceOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  const abortController = new AbortController();\n\n  // Get the latest mediaElement (even if nullish)\n  const mediaElementSignal = computed(() => owners.get().mediaElement);\n  // Get the latest presentationUrl (even if nullish)\n  const presentationUrlSignal = computed(() => state.get().presentation?.url);\n\n  const canSetupSignal = computed(() => !!mediaElementSignal.get() && !!presentationUrlSignal.get());\n\n  const mediaElementSrcSignal = computed(() => mediaElementSignal.get()?.src);\n  const mediaSourceSignal = computed(() => owners.get().mediaSource);\n  const shouldSetupSignal = computed(() => !mediaElementSrcSignal.get());\n\n  // NOTE: This should be cleaner and less brittle if/when Reactors have their own internal finite state. This is planned as followup work.\n  // (here, e.g. something like: \"preconditions_unmet\"|\"pending\"|\"setting_up\"|\"tearing_down\"|\"set_up\")\n  // This should also avoid needing nested effect().\n  const cleanupEffect = effect(() => {\n    if (!canSetupSignal.get() || !shouldSetupSignal.get()) return;\n    const mediaElement = mediaElementSignal.get() as HTMLMediaElement;\n    const { signal } = abortController;\n\n    const mediaSource = createMediaSource({ preferManaged: true });\n    // NOTE: Consider making MediaSource an Actor and using this in it.\n    const mediaSourceReadyState = observeMediaSourceReadyState(mediaSource, signal);\n    attachMediaSource(mediaSource, mediaElement);\n\n    const cleanupOwnersUpdateEffect = effect(() => {\n      // If we already have a MediaSource or the *internal* mediaSource is not yet fully attached, wait to add it to owners;\n      if (!!mediaSourceSignal.get() || mediaSourceReadyState.get() !== 'open') return;\n      owners.set(Object.assign({}, owners.get(), { mediaSource, mediaSourceReadyState }) as O);\n    });\n\n    return () => {\n      cleanupOwnersUpdateEffect();\n    };\n  });\n\n  return () => {\n    abortController?.abort();\n    cleanupEffect();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AA+BA,SAAgB,iBAA0E,EACxF,OACA,UAIa;CACb,MAAM,kBAAkB,IAAI,iBAAiB;CAG7C,MAAM,qBAAqB,eAAe,OAAO,KAAK,CAAC,aAAa;CAEpE,MAAM,wBAAwB,eAAe,MAAM,KAAK,CAAC,cAAc,IAAI;CAE3E,MAAM,iBAAiB,eAAe,CAAC,CAAC,mBAAmB,KAAK,IAAI,CAAC,CAAC,sBAAsB,KAAK,CAAC;CAElG,MAAM,wBAAwB,eAAe,mBAAmB,KAAK,EAAE,IAAI;CAC3E,MAAM,oBAAoB,eAAe,OAAO,KAAK,CAAC,YAAY;CAClE,MAAM,oBAAoB,eAAe,CAAC,sBAAsB,KAAK,CAAC;CAKtE,MAAM,gBAAgB,aAAa;AACjC,MAAI,CAAC,eAAe,KAAK,IAAI,CAAC,kBAAkB,KAAK,CAAE;EACvD,MAAM,eAAe,mBAAmB,KAAK;EAC7C,MAAM,EAAE,WAAW;EAEnB,MAAM,cAAc,kBAAkB,EAAE,eAAe,MAAM,CAAC;EAE9D,MAAM,wBAAwB,6BAA6B,aAAa,OAAO;AAC/E,oBAAkB,aAAa,aAAa;EAE5C,MAAM,4BAA4B,aAAa;AAE7C,OAAI,CAAC,CAAC,kBAAkB,KAAK,IAAI,sBAAsB,KAAK,KAAK,OAAQ;AACzE,UAAO,IAAI,OAAO,OAAO,EAAE,EAAE,OAAO,KAAK,EAAE;IAAE;IAAa;IAAuB,CAAC,CAAM;IACxF;AAEF,eAAa;AACX,8BAA2B;;GAE7B;AAEF,cAAa;AACX,mBAAiB,OAAO;AACxB,iBAAe"}

package/dist/dev/dom/features/setup-sourcebuffer.d.ts

@@ -0,0 +1,9 @@
+//#region src/dom/features/setup-sourcebuffer.d.ts
+/**
+ * Media track type for SourceBuffer setup.
+ * Text tracks are excluded as they don't use MSE SourceBuffers.
+ */
+type MediaTrackType = 'video' | 'audio';
+//#endregion
+export { MediaTrackType };
+//# sourceMappingURL=setup-sourcebuffer.d.ts.map

package/dist/dev/dom/features/setup-sourcebuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-sourcebuffer.d.ts","names":[],"sources":["../../../../src/dom/features/setup-sourcebuffer.ts"],"mappings":";AAYA;;;;AAAA,KAAY,cAAA"}

package/dist/dev/dom/features/setup-sourcebuffer.js

@@ -0,0 +1,78 @@
+import { effect } from "../../core/signals/effect.js";
+import { computed, update } from "../../core/signals/primitives.js";
+import { isResolvedTrack } from "../../core/types/index.js";
+import { BufferKeyByType, getSelectedTrack } from "../../core/utils/track-selection.js";
+import { createSourceBuffer } from "../media/mediasource-setup.js";
+import { createSourceBufferActor } from "../media/source-buffer-actor.js";
+//#region src/dom/features/setup-sourcebuffer.ts
+const ActorKeyByType = {
+	video: "videoBufferActor",
+	audio: "audioBufferActor"
+};
+/**
+* Build MIME codec string from track metadata.
+*
+* @param track - Resolved track with mimeType and codecs
+* @returns MIME codec string (e.g., 'video/mp4; codecs="avc1.42E01E,mp4a.40.2"')
+*
+* @example
+* buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })
+* // => 'video/mp4; codecs="avc1.42E01E"'
+*/
+function buildMimeCodec(track) {
+	const codecString = track.codecs?.join(",") ?? "";
+	return `${track.mimeType}; codecs="${codecString}"`;
+}
+/**
+* Setup all needed SourceBuffers as a single coordinated operation.
+*
+* Waits until ALL media tracks in the presentation are resolved with codecs,
+* then creates every SourceBuffer in one synchronous block before setting
+* owners. This guarantees that downstream consumers (e.g. loadSegments) never
+* see a partial set of SourceBuffers — preventing the Firefox bug where
+* appending to a video SourceBuffer before the audio SourceBuffer exists
+* causes mozHasAudio to be permanently false.
+*
+* Handles video-only, audio-only, and combined presentations correctly:
+* track types are derived from the presentation rather than hardcoded.
+*
+* @example
+* const cleanup = setupSourceBuffers({ state, owners });
+*/
+function setupSourceBuffers({ state, owners }) {
+	const presentationTypesSignal = computed(() => {
+		const { presentation } = state.get();
+		if (!presentation || !("selectionSets" in presentation)) return [];
+		return presentation.selectionSets.map(({ type }) => type).filter((type) => type === "video" || type === "audio");
+	});
+	const canSetupSignal = computed(() => {
+		const types = presentationTypesSignal.get();
+		if (!owners.get().mediaSource || types.length === 0) return false;
+		const s = state.get();
+		return types.every((type) => {
+			const track = getSelectedTrack(s, type);
+			return track && isResolvedTrack(track) && !!track.codecs?.length;
+		});
+	});
+	const shouldSetupSignal = computed(() => {
+		const o = owners.get();
+		return presentationTypesSignal.get().every((type) => !o[BufferKeyByType[type]]);
+	});
+	return effect(() => {
+		if (!canSetupSignal.get() || !shouldSetupSignal.get()) return;
+		const s = state.get();
+		const o = owners.get();
+		const patch = {};
+		for (const type of presentationTypesSignal.get()) {
+			const track = getSelectedTrack(s, type);
+			const buffer = createSourceBuffer(o.mediaSource, buildMimeCodec(track));
+			patch[BufferKeyByType[type]] = buffer;
+			patch[ActorKeyByType[type]] = createSourceBufferActor(buffer);
+		}
+		update(owners, patch);
+	});
+}
+//#endregion
+export { setupSourceBuffers };
+
+//# sourceMappingURL=setup-sourcebuffer.js.map

package/dist/dev/dom/features/setup-sourcebuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-sourcebuffer.js","names":[],"sources":["../../../../src/dom/features/setup-sourcebuffer.ts"],"sourcesContent":["import { effect } from '../../core/signals/effect';\nimport { computed, type Signal, update } from '../../core/signals/primitives';\nimport type { Presentation, ResolvedTrack } from '../../core/types';\nimport { isResolvedTrack } from '../../core/types';\nimport { BufferKeyByType, getSelectedTrack, type TrackSelectionState } from '../../core/utils/track-selection';\nimport { createSourceBuffer } from '../media/mediasource-setup';\nimport { createSourceBufferActor, type SourceBufferActor } from '../media/source-buffer-actor';\n\n/**\n * Media track type for SourceBuffer setup.\n * Text tracks are excluded as they don't use MSE SourceBuffers.\n */\nexport type MediaTrackType = 'video' | 'audio';\n\nconst ActorKeyByType = {\n  video: 'videoBufferActor',\n  audio: 'audioBufferActor',\n} as const satisfies Record<MediaTrackType, keyof SourceBufferOwners>;\n\n/**\n * State shape for SourceBuffer setup.\n */\nexport interface SourceBufferState extends TrackSelectionState {\n  presentation?: Presentation;\n  selectedVideoTrackId?: string;\n  selectedAudioTrackId?: string;\n}\n\n/**\n * Owners shape for SourceBuffer setup.\n */\nexport interface SourceBufferOwners {\n  mediaSource?: MediaSource;\n  videoBuffer?: SourceBuffer;\n  audioBuffer?: SourceBuffer;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n}\n\n/**\n * Build MIME codec string from track metadata.\n *\n * @param track - Resolved track with mimeType and codecs\n * @returns MIME codec string (e.g., 'video/mp4; codecs=\"avc1.42E01E,mp4a.40.2\"')\n *\n * @example\n * buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })\n * // => 'video/mp4; codecs=\"avc1.42E01E\"'\n */\nexport function buildMimeCodec(track: ResolvedTrack): string {\n  const codecString = track.codecs?.join(',') ?? '';\n  return `${track.mimeType}; codecs=\"${codecString}\"`;\n}\n\n/**\n * Setup all needed SourceBuffers as a single coordinated operation.\n *\n * Waits until ALL media tracks in the presentation are resolved with codecs,\n * then creates every SourceBuffer in one synchronous block before setting\n * owners. This guarantees that downstream consumers (e.g. loadSegments) never\n * see a partial set of SourceBuffers — preventing the Firefox bug where\n * appending to a video SourceBuffer before the audio SourceBuffer exists\n * causes mozHasAudio to be permanently false.\n *\n * Handles video-only, audio-only, and combined presentations correctly:\n * track types are derived from the presentation rather than hardcoded.\n *\n * @example\n * const cleanup = setupSourceBuffers({ state, owners });\n */\nexport function setupSourceBuffers<S extends SourceBufferState, O extends SourceBufferOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  // Derive which media track types this presentation actually contains\n  const presentationTypesSignal = computed((): MediaTrackType[] => {\n    const { presentation } = state.get();\n    if (!presentation || !('selectionSets' in presentation)) return [];\n    return presentation.selectionSets\n      .map(({ type }) => type)\n      .filter((type): type is MediaTrackType => type === 'video' || type === 'audio');\n  });\n\n  // All presentation track types must have a selected, resolved track with codecs\n  const canSetupSignal = computed(() => {\n    const types = presentationTypesSignal.get();\n    if (!owners.get().mediaSource || types.length === 0) return false;\n    const s = state.get();\n    return types.every((type) => {\n      const track = getSelectedTrack(s, type);\n      return track && isResolvedTrack(track) && !!track.codecs?.length;\n    });\n  });\n\n  // DOM-observable \"already done\" guard — once all presentation buffers exist in owners, setup has run\n  const shouldSetupSignal = computed(() => {\n    const o = owners.get();\n    return presentationTypesSignal.get().every((type) => !o[BufferKeyByType[type]]);\n  });\n\n  const cleanupEffect = effect(() => {\n    if (!canSetupSignal.get() || !shouldSetupSignal.get()) return;\n\n    const s = state.get();\n    const o = owners.get();\n\n    // Create all SourceBuffers synchronously — no await between addSourceBuffer\n    // calls — then set owners once so subscribers see all buffers simultaneously.\n    const patch: Partial<SourceBufferOwners> = {};\n\n    for (const type of presentationTypesSignal.get()) {\n      const track = getSelectedTrack(s, type) as ResolvedTrack;\n      const buffer = createSourceBuffer(o.mediaSource!, buildMimeCodec(track));\n      patch[BufferKeyByType[type]] = buffer;\n      patch[ActorKeyByType[type]] = createSourceBufferActor(buffer);\n    }\n\n    update(owners, patch);\n  });\n\n  return cleanupEffect;\n}\n"],"mappings":";;;;;;;AAcA,MAAM,iBAAiB;CACrB,OAAO;CACP,OAAO;CACR;;;;;;;;;;;AAgCD,SAAgB,eAAe,OAA8B;CAC3D,MAAM,cAAc,MAAM,QAAQ,KAAK,IAAI,IAAI;AAC/C,QAAO,GAAG,MAAM,SAAS,YAAY,YAAY;;;;;;;;;;;;;;;;;;AAmBnD,SAAgB,mBAA8E,EAC5F,OACA,UAIa;CAEb,MAAM,0BAA0B,eAAiC;EAC/D,MAAM,EAAE,iBAAiB,MAAM,KAAK;AACpC,MAAI,CAAC,gBAAgB,EAAE,mBAAmB,cAAe,QAAO,EAAE;AAClE,SAAO,aAAa,cACjB,KAAK,EAAE,WAAW,KAAK,CACvB,QAAQ,SAAiC,SAAS,WAAW,SAAS,QAAQ;GACjF;CAGF,MAAM,iBAAiB,eAAe;EACpC,MAAM,QAAQ,wBAAwB,KAAK;AAC3C,MAAI,CAAC,OAAO,KAAK,CAAC,eAAe,MAAM,WAAW,EAAG,QAAO;EAC5D,MAAM,IAAI,MAAM,KAAK;AACrB,SAAO,MAAM,OAAO,SAAS;GAC3B,MAAM,QAAQ,iBAAiB,GAAG,KAAK;AACvC,UAAO,SAAS,gBAAgB,MAAM,IAAI,CAAC,CAAC,MAAM,QAAQ;IAC1D;GACF;CAGF,MAAM,oBAAoB,eAAe;EACvC,MAAM,IAAI,OAAO,KAAK;AACtB,SAAO,wBAAwB,KAAK,CAAC,OAAO,SAAS,CAAC,EAAE,gBAAgB,OAAO;GAC/E;AAsBF,QApBsB,aAAa;AACjC,MAAI,CAAC,eAAe,KAAK,IAAI,CAAC,kBAAkB,KAAK,CAAE;EAEvD,MAAM,IAAI,MAAM,KAAK;EACrB,MAAM,IAAI,OAAO,KAAK;EAItB,MAAM,QAAqC,EAAE;AAE7C,OAAK,MAAM,QAAQ,wBAAwB,KAAK,EAAE;GAChD,MAAM,QAAQ,iBAAiB,GAAG,KAAK;GACvC,MAAM,SAAS,mBAAmB,EAAE,aAAc,eAAe,MAAM,CAAC;AACxE,SAAM,gBAAgB,SAAS;AAC/B,SAAM,eAAe,SAAS,wBAAwB,OAAO;;AAG/D,SAAO,QAAQ,MAAM;GACrB"}