@videojs/spf 10.0.0-beta.1 → 10.0.0-beta.11

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

@@ -0,0 +1,197 @@
+import { calculateBackBufferFlushPoint } from "../../core/buffer/back-buffer.js";
+import { calculateForwardFlushPoint, getSegmentsToLoad } from "../../core/buffer/forward-buffer.js";
+
+//#region src/dom/features/segment-loader-actor.ts
+/**
+* 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 `send()` on every incoming message, producing
+* an ordered LoadTask list. The runner drains that list sequentially. When a new
+* message arrives mid-run, send() replans and either continues the in-flight
+* operation (if still needed) or preempts it.
+*
+* @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) {
+	let pendingTasks = null;
+	let inFlightInitTrackId = null;
+	let inFlightSegmentId = null;
+	let abortController = null;
+	let running = false;
+	let destroyed = false;
+	const getBufferedSegments = (allSegments) => {
+		const bufferedIds = new Set(sourceBufferActor.snapshot.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 send().
+	*
+	* @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.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;
+	};
+	/**
+	* Execute a single LoadTask: fetch (if needed) then forward to SourceBufferActor.
+	* Sets/clears in-flight tracking around async operations so send() can make
+	* accurate continue/preempt decisions at any point during execution.
+	*
+	* @todo Rename alongside LoadTask (e.g. executeOp).
+	*/
+	const executeLoadTask = async (task) => {
+		const signal = abortController.signal;
+		try {
+			if (task.type === "remove") {
+				await sourceBufferActor.send(task, signal);
+				return;
+			}
+			if (task.type === "append-init") {
+				inFlightInitTrackId = task.meta.trackId;
+				if (!signal.aborted) {
+					const data = await fetchBytes(task, {
+						signal,
+						minChunkSize: Infinity
+					});
+					const isTrackSwitch = pendingTasks?.some((t) => t.type === "append-init" && t.meta.trackId !== task.meta.trackId);
+					if (!signal.aborted || !isTrackSwitch) {
+						const appendSignal = signal.aborted ? new AbortController().signal : signal;
+						await sourceBufferActor.send({
+							type: "append-init",
+							data,
+							meta: task.meta
+						}, appendSignal);
+					}
+				}
+				return;
+			}
+			inFlightSegmentId = task.meta.id;
+			if (!signal.aborted) {
+				const stream = await fetchBytes(task, { signal });
+				if (!signal.aborted) await sourceBufferActor.send({
+					type: "append-segment",
+					data: stream,
+					meta: task.meta
+				}, signal);
+			}
+		} finally {
+			inFlightInitTrackId = null;
+			inFlightSegmentId = null;
+		}
+	};
+	/**
+	* Drain the scheduled task list sequentially.
+	* After each task completes, checks for a pending replacement plan from send().
+	* If the signal was aborted and no new plan arrived, stops immediately.
+	*/
+	const runScheduled = async (initialTasks) => {
+		running = true;
+		abortController = new AbortController();
+		let scheduled = initialTasks;
+		while (scheduled.length > 0 && !destroyed) {
+			const task = scheduled[0];
+			scheduled = scheduled.slice(1);
+			try {
+				await executeLoadTask(task);
+			} catch (error) {
+				if (error instanceof Error && error.name === "AbortError") {} else {
+					console.error("Unexpected error in segment loader:", error);
+					scheduled = [];
+				}
+			}
+			if (pendingTasks !== null) {
+				scheduled = pendingTasks;
+				pendingTasks = null;
+				abortController = new AbortController();
+			} else if (abortController.signal.aborted) break;
+		}
+		abortController = null;
+		running = false;
+	};
+	return {
+		send(message) {
+			if (destroyed) return;
+			const allTasks = planTasks(message);
+			if (!running) {
+				if (allTasks.length === 0) return;
+				runScheduled(allTasks);
+				return;
+			}
+			if (inFlightSegmentId !== null && allTasks.some((t) => t.type === "append-segment" && t.meta.id === inFlightSegmentId) || inFlightInitTrackId !== null && allTasks.some((t) => t.type === "append-init" && t.meta.trackId === inFlightInitTrackId)) pendingTasks = allTasks.filter((t) => !(t.type === "append-segment" && t.meta.id === inFlightSegmentId) && !(t.type === "append-init" && t.meta.trackId === inFlightInitTrackId));
+			else {
+				pendingTasks = allTasks;
+				abortController?.abort();
+			}
+		},
+		destroy() {
+			destroyed = true;
+			abortController?.abort();
+		}
+	};
+}
+
+//#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 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\nexport interface SegmentLoaderActor {\n  send(message: SegmentLoaderMessage): void;\n  destroy(): void;\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 `send()` on every incoming message, producing\n * an ordered LoadTask list. The runner drains that list sequentially. When a new\n * message arrives mid-run, send() replans and either continues the in-flight\n * operation (if still needed) or preempts it.\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: (\n    addressable: AddressableObject,\n    options?: RequestInit & { minChunkSize?: number }\n  ) => Promise<AsyncIterable<Uint8Array>>\n): SegmentLoaderActor {\n  let pendingTasks: LoadTask[] | null = null;\n  let inFlightInitTrackId: string | null = null;\n  let inFlightSegmentId: string | null = null;\n  let abortController: AbortController | null = null;\n  let running = false;\n  let destroyed = false;\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(sourceBufferActor.snapshot.context.segments.filter((s) => !s.partial).map((s) => s.id));\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 send().\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.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  /**\n   * Execute a single LoadTask: fetch (if needed) then forward to SourceBufferActor.\n   * Sets/clears in-flight tracking around async operations so send() can make\n   * accurate continue/preempt decisions at any point during execution.\n   *\n   * @todo Rename alongside LoadTask (e.g. executeOp).\n   */\n  const executeLoadTask = async (task: LoadTask): Promise<void> => {\n    const signal = abortController!.signal;\n    try {\n      if (task.type === 'remove') {\n        await sourceBufferActor.send(task, signal);\n        return;\n      }\n\n      if (task.type === 'append-init') {\n        inFlightInitTrackId = task.meta.trackId;\n        if (!signal.aborted) {\n          // Init segments are small and need the full body before the\n          // same-track-seek vs track-switch commit decision can be made.\n          // minChunkSize: Infinity causes ChunkedStreamIterable to accumulate\n          // all chunks and yield exactly one — equivalent to arrayBuffer() but\n          // through the same streaming path as media segments.\n          const data = await fetchBytes(task, { signal, minChunkSize: Infinity });\n          // For seeks on the same track: commit even if aborted — avoids re-fetching the\n          // same init next time. For track switches: don't commit the old track's init;\n          // the new track's init follows in pendingTasks.\n          const isTrackSwitch = pendingTasks?.some(\n            (t) => t.type === 'append-init' && t.meta.trackId !== task.meta.trackId\n          );\n          if (!signal.aborted || !isTrackSwitch) {\n            const appendSignal = signal.aborted ? new AbortController().signal : signal;\n            await sourceBufferActor.send({ type: 'append-init', data, meta: task.meta }, appendSignal);\n          }\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      inFlightSegmentId = task.meta.id;\n      if (!signal.aborted) {\n        const stream = await fetchBytes(task, { signal });\n        if (!signal.aborted) {\n          await sourceBufferActor.send({ type: 'append-segment', data: stream, meta: task.meta }, signal);\n        }\n      }\n    } finally {\n      inFlightInitTrackId = null;\n      inFlightSegmentId = null;\n    }\n  };\n\n  /**\n   * Drain the scheduled task list sequentially.\n   * After each task completes, checks for a pending replacement plan from send().\n   * If the signal was aborted and no new plan arrived, stops immediately.\n   */\n  const runScheduled = async (initialTasks: LoadTask[]): Promise<void> => {\n    running = true;\n    abortController = new AbortController();\n    let scheduled = initialTasks;\n\n    while (scheduled.length > 0 && !destroyed) {\n      const task = scheduled[0]!;\n      scheduled = scheduled.slice(1);\n\n      try {\n        await executeLoadTask(task);\n      } catch (error) {\n        if (error instanceof Error && error.name === 'AbortError') {\n          // Abort is handled in the post-task check below.\n        } else {\n          console.error('Unexpected error in segment loader:', error);\n          // Non-abort error (e.g. network failure on init): don't continue with\n          // remaining tasks in this sequence — they depend on the failed step.\n          // A pending replacement plan (if any) will still be picked up below.\n          scheduled = [];\n        }\n      }\n\n      if (pendingTasks !== null) {\n        // A new plan arrived while this task was running — switch to it.\n        scheduled = pendingTasks;\n        pendingTasks = null;\n        abortController = new AbortController();\n      } else if (abortController.signal.aborted) {\n        // Aborted with no replacement plan — stop.\n        break;\n      }\n    }\n\n    abortController = null;\n    running = false;\n  };\n\n  return {\n    send(message: SegmentLoaderMessage) {\n      if (destroyed) return;\n\n      const allTasks = planTasks(message);\n\n      if (!running) {\n        if (allTasks.length === 0) return;\n        runScheduled(allTasks);\n        return;\n      }\n\n      // Determine whether the in-flight operation is still needed for the new plan.\n      const inFlightStillNeeded =\n        (inFlightSegmentId !== null &&\n          allTasks.some((t) => t.type === 'append-segment' && t.meta.id === inFlightSegmentId)) ||\n        (inFlightInitTrackId !== null &&\n          allTasks.some((t) => t.type === 'append-init' && t.meta.trackId === inFlightInitTrackId));\n\n      if (inFlightStillNeeded) {\n        // Continue: the in-flight operation covers something the new plan needs.\n        // Queue everything except the in-flight item — it will complete on its own.\n        pendingTasks = allTasks.filter(\n          (t) =>\n            !(t.type === 'append-segment' && t.meta.id === inFlightSegmentId) &&\n            !(t.type === 'append-init' && t.meta.trackId === inFlightInitTrackId)\n        );\n      } else {\n        // Preempt: in-flight work is not needed for the new plan. Abort and replan.\n        pendingTasks = allTasks;\n        abortController?.abort();\n      }\n    },\n\n    destroy() {\n      destroyed = true;\n      abortController?.abort();\n    },\n  };\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,55 @@
+import { attachMediaSource, createMediaSource, waitForSourceOpen } from "../media/mediasource-setup.js";
+import { combineLatest } from "../../core/reactive/combine-latest.js";
+import { isNil } from "@videojs/utils/predicate";
+
+//#region src/dom/features/setup-mediasource.ts
+/**
+* Check if we have the minimum requirements to create MediaSource.
+*/
+function canSetup(state, owners) {
+	return !isNil(owners.mediaElement) && !isNil(state.presentation?.url);
+}
+/**
+* Check if we should proceed with MediaSource creation.
+* Placeholder for future conditions (e.g., checking if already created).
+*/
+function shouldSetup(_state, owners) {
+	return isNil(owners.mediaSource);
+}
+/**
+* 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 }) {
+	let settingUp = false;
+	let abortController = null;
+	const unsubscribe = combineLatest([state, owners]).subscribe(async ([currentState, currentOwners]) => {
+		if (!canSetup(currentState, currentOwners) || !shouldSetup(currentState, currentOwners) || settingUp) return;
+		try {
+			settingUp = true;
+			abortController = new AbortController();
+			const mediaSource = createMediaSource({ preferManaged: true });
+			attachMediaSource(mediaSource, currentOwners.mediaElement);
+			await waitForSourceOpen(mediaSource, abortController.signal);
+			owners.patch({ mediaSource });
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "AbortError") return;
+			throw error;
+		} finally {
+			settingUp = false;
+		}
+	});
+	return () => {
+		abortController?.abort();
+		unsubscribe();
+	};
+}
+
+//#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 { isNil } from '@videojs/utils/predicate';\nimport { combineLatest } from '../../core/reactive/combine-latest';\nimport type { WritableState } from '../../core/state/create-state';\nimport type { Presentation } from '../../core/types';\nimport { attachMediaSource, createMediaSource, waitForSourceOpen } 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}\n\n/**\n * Check if we have the minimum requirements to create MediaSource.\n */\nexport function canSetup(state: MediaSourceState, owners: MediaSourceOwners): boolean {\n  return !isNil(owners.mediaElement) && !isNil(state.presentation?.url);\n}\n\n/**\n * Check if we should proceed with MediaSource creation.\n * Placeholder for future conditions (e.g., checking if already created).\n */\nexport function shouldSetup(_state: MediaSourceState, owners: MediaSourceOwners): boolean {\n  // Don't create if we already have one\n  return isNil(owners.mediaSource);\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({\n  state,\n  owners,\n}: {\n  state: WritableState<MediaSourceState>;\n  owners: WritableState<MediaSourceOwners>;\n}): () => void {\n  let settingUp = false;\n  let abortController: AbortController | null = null;\n\n  const unsubscribe = combineLatest([state, owners]).subscribe(\n    async ([currentState, currentOwners]: [MediaSourceState, MediaSourceOwners]) => {\n      if (!canSetup(currentState, currentOwners) || !shouldSetup(currentState, currentOwners) || settingUp) return;\n\n      try {\n        settingUp = true;\n        abortController = new AbortController();\n\n        // Prefer ManagedMediaSource when available (Safari 17+). attachMediaSource\n        // handles the srcObject path and sets disableRemotePlayback automatically.\n        const mediaSource = createMediaSource({ preferManaged: true });\n\n        // Attach to element\n        attachMediaSource(mediaSource, currentOwners.mediaElement!);\n\n        // Wait for sourceopen — aborted if destroy() is called before it fires\n        await waitForSourceOpen(mediaSource, abortController.signal);\n\n        owners.patch({ mediaSource });\n      } catch (error) {\n        if (error instanceof DOMException && error.name === 'AbortError') return;\n        throw error;\n      } finally {\n        settingUp = false;\n      }\n    }\n  );\n\n  return () => {\n    abortController?.abort();\n    unsubscribe();\n  };\n}\n"],"mappings":";;;;;;;;AAwBA,SAAgB,SAAS,OAAyB,QAAoC;AACpF,QAAO,CAAC,MAAM,OAAO,aAAa,IAAI,CAAC,MAAM,MAAM,cAAc,IAAI;;;;;;AAOvE,SAAgB,YAAY,QAA0B,QAAoC;AAExF,QAAO,MAAM,OAAO,YAAY;;;;;;;;;;;AAYlC,SAAgB,iBAAiB,EAC/B,OACA,UAIa;CACb,IAAI,YAAY;CAChB,IAAI,kBAA0C;CAE9C,MAAM,cAAc,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC,UACjD,OAAO,CAAC,cAAc,mBAA0D;AAC9E,MAAI,CAAC,SAAS,cAAc,cAAc,IAAI,CAAC,YAAY,cAAc,cAAc,IAAI,UAAW;AAEtG,MAAI;AACF,eAAY;AACZ,qBAAkB,IAAI,iBAAiB;GAIvC,MAAM,cAAc,kBAAkB,EAAE,eAAe,MAAM,CAAC;AAG9D,qBAAkB,aAAa,cAAc,aAAc;AAG3D,SAAM,kBAAkB,aAAa,gBAAgB,OAAO;AAE5D,UAAO,MAAM,EAAE,aAAa,CAAC;WACtB,OAAO;AACd,OAAI,iBAAiB,gBAAgB,MAAM,SAAS,aAAc;AAClE,SAAM;YACE;AACR,eAAY;;GAGjB;AAED,cAAa;AACX,mBAAiB,OAAO;AACxB,eAAa"}

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":";;;;;KAaY,cAAA"}

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

@@ -0,0 +1,70 @@
+import { isResolvedTrack } from "../../core/types/index.js";
+import { createSourceBuffer } from "../media/mediasource-setup.js";
+import { combineLatest } from "../../core/reactive/combine-latest.js";
+import { getSelectedTrack } from "../../core/utils/track-selection.js";
+import { createSourceBufferActor } from "../media/source-buffer-actor.js";
+import "@videojs/utils/predicate";
+
+//#region src/dom/features/setup-sourcebuffer.ts
+/**
+* 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 selected tracks (video and/or audio) are resolved with
+* codecs, then creates every SourceBuffer in one synchronous block before
+* patching 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:
+* only the tracks that are actually selected are waited on and created.
+*
+* @example
+* const cleanup = setupSourceBuffers({ state, owners });
+*/
+function setupSourceBuffers({ state, owners }) {
+	let setupDone = false;
+	return combineLatest([state, owners]).subscribe(async ([currentState, currentOwners]) => {
+		if (setupDone) return;
+		if (!currentOwners.mediaSource) return;
+		const videoSelected = !!currentState.selectedVideoTrackId;
+		const audioSelected = !!currentState.selectedAudioTrackId;
+		if (!videoSelected && !audioSelected) return;
+		const videoTrack = videoSelected ? getSelectedTrack(currentState, "video") : null;
+		const audioTrack = audioSelected ? getSelectedTrack(currentState, "audio") : null;
+		if (videoSelected && (!videoTrack || !isResolvedTrack(videoTrack) || !videoTrack.codecs?.length)) return;
+		if (audioSelected && (!audioTrack || !isResolvedTrack(audioTrack) || !audioTrack.codecs?.length)) return;
+		setupDone = true;
+		const patch = {};
+		if (videoSelected && videoTrack && isResolvedTrack(videoTrack)) {
+			const buffer = createSourceBuffer(currentOwners.mediaSource, buildMimeCodec(videoTrack));
+			patch.videoBuffer = buffer;
+			patch.videoBufferActor = createSourceBufferActor(buffer);
+		}
+		if (audioSelected && audioTrack && isResolvedTrack(audioTrack)) {
+			const buffer = createSourceBuffer(currentOwners.mediaSource, buildMimeCodec(audioTrack));
+			patch.audioBuffer = buffer;
+			patch.audioBufferActor = createSourceBufferActor(buffer);
+		}
+		owners.patch(patch);
+		await new Promise((resolve) => requestAnimationFrame(resolve));
+	});
+}
+
+//#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 { isUndefined } from '@videojs/utils/predicate';\nimport { combineLatest } from '../../core/reactive/combine-latest';\nimport type { WritableState } from '../../core/state/create-state';\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\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 * Check if we can setup SourceBuffer for track type.\n *\n * Requires:\n * - MediaSource exists in owners\n * - Track is selected\n *\n * Note: We don't check mediaSource.readyState because owners holds references\n * to mutable objects. Changes to properties on those objects won't trigger\n * observations. Instead, setupMediaSource only patches owners.mediaSource after\n * it's already open, so if it exists in owners, it's ready to use.\n *\n * Note: Track does not need to be resolved yet. The orchestration will wait\n * for the track to be resolved (via resolveTrack) before creating the SourceBuffer.\n */\nexport function canSetupBuffer(state: SourceBufferState, owners: SourceBufferOwners, type: MediaTrackType): boolean {\n  // MediaSource exists (already open - see note above)\n  if (!owners.mediaSource) {\n    return false;\n  }\n\n  // Need selected track (doesn't need to be resolved yet)\n  const track = getSelectedTrack(state, type);\n  if (!track) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Check if we should create SourceBuffer (not already created).\n */\nexport function shouldSetupBuffer(owners: SourceBufferOwners, type: MediaTrackType): boolean {\n  const bufferKey = BufferKeyByType[type];\n  return isUndefined(owners[bufferKey]);\n}\n\n/**\n * Setup all needed SourceBuffers as a single coordinated operation.\n *\n * Waits until ALL selected tracks (video and/or audio) are resolved with\n * codecs, then creates every SourceBuffer in one synchronous block before\n * patching owners. This guarantees that downstream consumers (e.g.\n * loadSegments) never see a partial set of SourceBuffers — preventing the\n * Firefox bug where appending to a video SourceBuffer before the audio\n * SourceBuffer exists causes mozHasAudio to be permanently false.\n *\n * Handles video-only, audio-only, and combined presentations correctly:\n * only the tracks that are actually selected are waited on and created.\n *\n * @example\n * const cleanup = setupSourceBuffers({ state, owners });\n */\nexport function setupSourceBuffers({\n  state,\n  owners,\n}: {\n  state: WritableState<SourceBufferState>;\n  owners: WritableState<SourceBufferOwners>;\n}): () => void {\n  let setupDone = false;\n\n  const cleanup = combineLatest([state, owners]).subscribe(\n    async ([currentState, currentOwners]: [SourceBufferState, SourceBufferOwners]) => {\n      if (setupDone) return;\n      if (!currentOwners.mediaSource) return;\n\n      const videoSelected = !!currentState.selectedVideoTrackId;\n      const audioSelected = !!currentState.selectedAudioTrackId;\n\n      if (!videoSelected && !audioSelected) return;\n\n      const videoTrack = videoSelected ? getSelectedTrack(currentState, 'video') : null;\n      const audioTrack = audioSelected ? getSelectedTrack(currentState, 'audio') : null;\n\n      // Wait until every selected track is resolved with codecs before\n      // creating any SourceBuffer. This is the coordination guarantee.\n      if (videoSelected && (!videoTrack || !isResolvedTrack(videoTrack) || !videoTrack.codecs?.length)) return;\n      if (audioSelected && (!audioTrack || !isResolvedTrack(audioTrack) || !audioTrack.codecs?.length)) return;\n\n      setupDone = true;\n\n      // Create all SourceBuffers synchronously — no await between addSourceBuffer\n      // calls — then patch owners once so subscribers see all buffers simultaneously.\n      const patch: Partial<SourceBufferOwners> = {};\n\n      if (videoSelected && videoTrack && isResolvedTrack(videoTrack)) {\n        const buffer = createSourceBuffer(currentOwners.mediaSource!, buildMimeCodec(videoTrack));\n        patch.videoBuffer = buffer;\n        patch.videoBufferActor = createSourceBufferActor(buffer);\n      }\n\n      if (audioSelected && audioTrack && isResolvedTrack(audioTrack)) {\n        const buffer = createSourceBuffer(currentOwners.mediaSource!, buildMimeCodec(audioTrack));\n        patch.audioBuffer = buffer;\n        patch.audioBufferActor = createSourceBufferActor(buffer);\n      }\n\n      owners.patch(patch);\n\n      // Wait a frame to allow async state updates to flush before downstream\n      // orchestrations (loadSegments) begin reacting to the new owners.\n      await new Promise((resolve) => requestAnimationFrame(resolve));\n    }\n  );\n\n  return cleanup;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6CA,SAAgB,eAAe,OAA8B;CAC3D,MAAM,cAAc,MAAM,QAAQ,KAAK,IAAI,IAAI;AAC/C,QAAO,GAAG,MAAM,SAAS,YAAY,YAAY;;;;;;;;;;;;;;;;;;AAyDnD,SAAgB,mBAAmB,EACjC,OACA,UAIa;CACb,IAAI,YAAY;AA8ChB,QA5CgB,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC,UAC7C,OAAO,CAAC,cAAc,mBAA4D;AAChF,MAAI,UAAW;AACf,MAAI,CAAC,cAAc,YAAa;EAEhC,MAAM,gBAAgB,CAAC,CAAC,aAAa;EACrC,MAAM,gBAAgB,CAAC,CAAC,aAAa;AAErC,MAAI,CAAC,iBAAiB,CAAC,cAAe;EAEtC,MAAM,aAAa,gBAAgB,iBAAiB,cAAc,QAAQ,GAAG;EAC7E,MAAM,aAAa,gBAAgB,iBAAiB,cAAc,QAAQ,GAAG;AAI7E,MAAI,kBAAkB,CAAC,cAAc,CAAC,gBAAgB,WAAW,IAAI,CAAC,WAAW,QAAQ,QAAS;AAClG,MAAI,kBAAkB,CAAC,cAAc,CAAC,gBAAgB,WAAW,IAAI,CAAC,WAAW,QAAQ,QAAS;AAElG,cAAY;EAIZ,MAAM,QAAqC,EAAE;AAE7C,MAAI,iBAAiB,cAAc,gBAAgB,WAAW,EAAE;GAC9D,MAAM,SAAS,mBAAmB,cAAc,aAAc,eAAe,WAAW,CAAC;AACzF,SAAM,cAAc;AACpB,SAAM,mBAAmB,wBAAwB,OAAO;;AAG1D,MAAI,iBAAiB,cAAc,gBAAgB,WAAW,EAAE;GAC9D,MAAM,SAAS,mBAAmB,cAAc,aAAc,eAAe,WAAW,CAAC;AACzF,SAAM,cAAc;AACpB,SAAM,mBAAmB,wBAAwB,OAAO;;AAG1D,SAAO,MAAM,MAAM;AAInB,QAAM,IAAI,SAAS,YAAY,sBAAsB,QAAQ,CAAC;GAEjE"}

package/dist/dev/dom/features/setup-text-tracks.js

@@ -0,0 +1,88 @@
+import { combineLatest } from "../../core/reactive/combine-latest.js";
+
+//#region src/dom/features/setup-text-tracks.ts
+/**
+* Get all text tracks from presentation.
+*/
+function getTextTracks(presentation) {
+	if (!presentation?.selectionSets) return [];
+	const textSet = presentation.selectionSets.find((set) => set.type === "text");
+	if (!textSet?.switchingSets?.[0]?.tracks) return [];
+	return textSet.switchingSets[0].tracks;
+}
+/**
+* Check if we can setup text tracks.
+*
+* Requires:
+* - mediaElement exists
+* - presentation has text tracks to setup
+*/
+function canSetupTextTracks(state, owners) {
+	return !!owners.mediaElement && !!getTextTracks(state.presentation).length;
+}
+/**
+* Check if we should setup text tracks (not already set up).
+*/
+function shouldSetupTextTracks(owners) {
+	return !owners.textTracks;
+}
+/**
+* Create a track element for a text track.
+*
+* Note: We use DOM <track> elements instead of the TextTrack JS API
+* because there's no way to remove TextTracks added via addTextTrack().
+*/
+function createTrackElement(track) {
+	const trackElement = document.createElement("track");
+	trackElement.id = track.id;
+	trackElement.kind = track.kind;
+	trackElement.label = track.label;
+	if (track.language) trackElement.srclang = track.language;
+	if (track.default) trackElement.default = true;
+	trackElement.src = track.url;
+	return trackElement;
+}
+/**
+* Setup text tracks orchestration.
+*
+* Triggers when:
+* - mediaElement exists
+* - presentation is resolved (has text tracks)
+*
+* Creates <track> elements for all text tracks and adds them as children
+* to the media element. This allows the browser's native text track rendering.
+*
+* Note: Uses DOM track elements instead of TextTrack API because tracks
+* added via addTextTrack() cannot be removed.
+*
+* @example
+* const cleanup = setupTextTracks({ state, owners });
+*/
+function setupTextTracks({ state, owners }) {
+	let hasSetup = false;
+	let createdTracks = [];
+	const unsubscribe = combineLatest([state, owners]).subscribe(([s, o]) => {
+		if (hasSetup) return;
+		if (!canSetupTextTracks(s, o) || !shouldSetupTextTracks(o)) return;
+		hasSetup = true;
+		const textTracks = getTextTracks(s.presentation);
+		if (textTracks.length === 0) return;
+		const trackMap = /* @__PURE__ */ new Map();
+		for (const track of textTracks) {
+			const trackElement = createTrackElement(track);
+			o.mediaElement.appendChild(trackElement);
+			trackMap.set(track.id, trackElement);
+			createdTracks.push(trackElement);
+		}
+		owners.patch({ textTracks: trackMap });
+	});
+	return () => {
+		for (const trackElement of createdTracks) trackElement.remove();
+		createdTracks = [];
+		unsubscribe();
+	};
+}
+
+//#endregion
+export { setupTextTracks };
+//# sourceMappingURL=setup-text-tracks.js.map

package/dist/dev/dom/features/setup-text-tracks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-text-tracks.js","names":[],"sources":["../../../../src/dom/features/setup-text-tracks.ts"],"sourcesContent":["import { combineLatest } from '../../core/reactive/combine-latest';\nimport type { WritableState } from '../../core/state/create-state';\nimport type { PartiallyResolvedTextTrack, Presentation } from '../../core/types';\n\n/**\n * State shape for text track setup.\n */\nexport interface TextTrackState {\n  presentation?: Presentation | undefined;\n  selectedTextTrackId?: string | undefined;\n}\n\n/**\n * Owners shape for text track setup.\n */\nexport interface TextTrackOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n  textTracks?: Map<string, HTMLTrackElement>;\n}\n\n/**\n * Get all text tracks from presentation.\n */\nfunction getTextTracks(presentation?: Presentation): PartiallyResolvedTextTrack[] {\n  if (!presentation?.selectionSets) return [];\n\n  const textSet = presentation.selectionSets.find((set) => set.type === 'text');\n  if (!textSet?.switchingSets?.[0]?.tracks) return [];\n\n  return textSet.switchingSets[0].tracks as PartiallyResolvedTextTrack[];\n}\n\n/**\n * Check if we can setup text tracks.\n *\n * Requires:\n * - mediaElement exists\n * - presentation has text tracks to setup\n */\nexport function canSetupTextTracks(state: TextTrackState, owners: TextTrackOwners): boolean {\n  return !!owners.mediaElement && !!getTextTracks(state.presentation).length;\n}\n\n/**\n * Check if we should setup text tracks (not already set up).\n */\nexport function shouldSetupTextTracks(owners: TextTrackOwners): boolean {\n  return !owners.textTracks;\n}\n\n/**\n * Create a track element for a text track.\n *\n * Note: We use DOM <track> elements instead of the TextTrack JS API\n * because there's no way to remove TextTracks added via addTextTrack().\n */\nfunction createTrackElement(track: PartiallyResolvedTextTrack): HTMLTrackElement {\n  const trackElement = document.createElement('track');\n\n  trackElement.id = track.id;\n  trackElement.kind = track.kind;\n  trackElement.label = track.label;\n\n  if (track.language) {\n    trackElement.srclang = track.language;\n  }\n\n  if (track.default) {\n    trackElement.default = true;\n  }\n\n  // Set src to track URL\n  trackElement.src = track.url;\n\n  return trackElement;\n}\n\n/**\n * Setup text tracks orchestration.\n *\n * Triggers when:\n * - mediaElement exists\n * - presentation is resolved (has text tracks)\n *\n * Creates <track> elements for all text tracks and adds them as children\n * to the media element. This allows the browser's native text track rendering.\n *\n * Note: Uses DOM track elements instead of TextTrack API because tracks\n * added via addTextTrack() cannot be removed.\n *\n * @example\n * const cleanup = setupTextTracks({ state, owners });\n */\nexport function setupTextTracks({\n  state,\n  owners,\n}: {\n  state: WritableState<TextTrackState>;\n  owners: WritableState<TextTrackOwners>;\n}): () => void {\n  let hasSetup = false;\n  let createdTracks: HTMLTrackElement[] = [];\n\n  const unsubscribe = combineLatest([state, owners]).subscribe(([s, o]: [TextTrackState, TextTrackOwners]) => {\n    // Check orchestration conditions\n    if (hasSetup) return; // Only run once\n    if (!canSetupTextTracks(s, o) || !shouldSetupTextTracks(o)) return;\n\n    // Mark as setup before doing any work to prevent re-entry\n    hasSetup = true;\n\n    const textTracks = getTextTracks(s.presentation);\n    if (textTracks.length === 0) return;\n\n    const trackMap = new Map<string, HTMLTrackElement>();\n\n    // Create track elements for all text tracks\n    for (const track of textTracks) {\n      const trackElement = createTrackElement(track);\n      o.mediaElement!.appendChild(trackElement);\n      trackMap.set(track.id, trackElement);\n      createdTracks.push(trackElement);\n    }\n\n    // Update owners with track element map\n    owners.patch({ textTracks: trackMap });\n  });\n\n  // Return cleanup function\n  return () => {\n    // Remove all created track elements\n    for (const trackElement of createdTracks) {\n      trackElement.remove();\n    }\n    createdTracks = [];\n    unsubscribe();\n  };\n}\n"],"mappings":";;;;;;AAuBA,SAAS,cAAc,cAA2D;AAChF,KAAI,CAAC,cAAc,cAAe,QAAO,EAAE;CAE3C,MAAM,UAAU,aAAa,cAAc,MAAM,QAAQ,IAAI,SAAS,OAAO;AAC7E,KAAI,CAAC,SAAS,gBAAgB,IAAI,OAAQ,QAAO,EAAE;AAEnD,QAAO,QAAQ,cAAc,GAAG;;;;;;;;;AAUlC,SAAgB,mBAAmB,OAAuB,QAAkC;AAC1F,QAAO,CAAC,CAAC,OAAO,gBAAgB,CAAC,CAAC,cAAc,MAAM,aAAa,CAAC;;;;;AAMtE,SAAgB,sBAAsB,QAAkC;AACtE,QAAO,CAAC,OAAO;;;;;;;;AASjB,SAAS,mBAAmB,OAAqD;CAC/E,MAAM,eAAe,SAAS,cAAc,QAAQ;AAEpD,cAAa,KAAK,MAAM;AACxB,cAAa,OAAO,MAAM;AAC1B,cAAa,QAAQ,MAAM;AAE3B,KAAI,MAAM,SACR,cAAa,UAAU,MAAM;AAG/B,KAAI,MAAM,QACR,cAAa,UAAU;AAIzB,cAAa,MAAM,MAAM;AAEzB,QAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,gBAAgB,EAC9B,OACA,UAIa;CACb,IAAI,WAAW;CACf,IAAI,gBAAoC,EAAE;CAE1C,MAAM,cAAc,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC,WAAW,CAAC,GAAG,OAA0C;AAE1G,MAAI,SAAU;AACd,MAAI,CAAC,mBAAmB,GAAG,EAAE,IAAI,CAAC,sBAAsB,EAAE,CAAE;AAG5D,aAAW;EAEX,MAAM,aAAa,cAAc,EAAE,aAAa;AAChD,MAAI,WAAW,WAAW,EAAG;EAE7B,MAAM,2BAAW,IAAI,KAA+B;AAGpD,OAAK,MAAM,SAAS,YAAY;GAC9B,MAAM,eAAe,mBAAmB,MAAM;AAC9C,KAAE,aAAc,YAAY,aAAa;AACzC,YAAS,IAAI,MAAM,IAAI,aAAa;AACpC,iBAAc,KAAK,aAAa;;AAIlC,SAAO,MAAM,EAAE,YAAY,UAAU,CAAC;GACtC;AAGF,cAAa;AAEX,OAAK,MAAM,gBAAgB,cACzB,cAAa,QAAQ;AAEvB,kBAAgB,EAAE;AAClB,eAAa"}

package/dist/dev/dom/features/sync-selected-text-track-from-dom.js

@@ -0,0 +1,63 @@
+import { listen } from "@videojs/utils/dom";
+
+//#region src/dom/features/sync-selected-text-track-from-dom.ts
+/**
+* Sync selectedTextTrackId from DOM text track mode changes.
+*
+* Listens to the `change` event on `media.textTracks` and updates
+* `selectedTextTrackId` when external code (e.g. the captions button via
+* `toggleSubtitles()`) changes a subtitle/caption track mode to 'showing'.
+*
+* This bridges the core store's `toggleSubtitles()` with SPF's reactive text
+* track pipeline (`syncTextTrackModes`, `loadTextTrackCues`). Without this
+* bridge, direct DOM mode changes would be immediately overridden by
+* `syncTextTrackModes` on the next SPF state update.
+*
+* When a subtitle/caption track's mode is 'showing', its DOM `id` — which
+* matches the SPF track ID set by `setupTextTracks` — is written to
+* `selectedTextTrackId`. When no subtitle/caption track is 'showing',
+* `selectedTextTrackId` is cleared along with the deselected track's
+* `textBufferState` entry — setting mode to 'disabled' clears native cues from
+* the track element, so the buffer must be reset to re-fetch cues on re-enable.
+*
+* @example
+* const cleanup = syncSelectedTextTrackFromDom({ state, owners });
+*/
+function syncSelectedTextTrackFromDom({ state, owners }) {
+	let lastMediaElement;
+	let removeListener = null;
+	const unsubscribe = owners.subscribe((currentOwners) => {
+		const { mediaElement } = currentOwners;
+		if (mediaElement === lastMediaElement) return;
+		removeListener?.();
+		removeListener = null;
+		lastMediaElement = mediaElement;
+		if (!mediaElement) return;
+		const sync = () => {
+			const newId = Array.from(mediaElement.textTracks).find((t) => t.mode === "showing" && (t.kind === "subtitles" || t.kind === "captions"))?.id || void 0;
+			const current = state.current;
+			if (current.selectedTextTrackId === newId) return;
+			if (newId) state.patch({ selectedTextTrackId: newId });
+			else {
+				const prevId = current.selectedTextTrackId;
+				if (prevId && current.textBufferState?.[prevId]) {
+					const next = { ...current.textBufferState };
+					delete next[prevId];
+					state.patch({
+						selectedTextTrackId: void 0,
+						textBufferState: next
+					});
+				} else state.patch({ selectedTextTrackId: void 0 });
+			}
+		};
+		removeListener = listen(mediaElement.textTracks, "change", sync);
+	});
+	return () => {
+		removeListener?.();
+		unsubscribe();
+	};
+}
+
+//#endregion
+export { syncSelectedTextTrackFromDom };
+//# sourceMappingURL=sync-selected-text-track-from-dom.js.map

package/dist/dev/dom/features/sync-selected-text-track-from-dom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-selected-text-track-from-dom.js","names":[],"sources":["../../../../src/dom/features/sync-selected-text-track-from-dom.ts"],"sourcesContent":["import { listen } from '@videojs/utils/dom';\nimport type { WritableState } from '../../core/state/create-state';\nimport type { TextTrackBufferState } from './load-text-track-cues';\n\n/**\n * State shape for DOM-driven text track selection.\n */\nexport interface SelectedTextTrackFromDomState {\n  selectedTextTrackId?: string | undefined;\n  textBufferState?: TextTrackBufferState | undefined;\n}\n\n/**\n * Owners shape for DOM-driven text track selection.\n */\nexport interface SelectedTextTrackFromDomOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\n/**\n * Sync selectedTextTrackId from DOM text track mode changes.\n *\n * Listens to the `change` event on `media.textTracks` and updates\n * `selectedTextTrackId` when external code (e.g. the captions button via\n * `toggleSubtitles()`) changes a subtitle/caption track mode to 'showing'.\n *\n * This bridges the core store's `toggleSubtitles()` with SPF's reactive text\n * track pipeline (`syncTextTrackModes`, `loadTextTrackCues`). Without this\n * bridge, direct DOM mode changes would be immediately overridden by\n * `syncTextTrackModes` on the next SPF state update.\n *\n * When a subtitle/caption track's mode is 'showing', its DOM `id` — which\n * matches the SPF track ID set by `setupTextTracks` — is written to\n * `selectedTextTrackId`. When no subtitle/caption track is 'showing',\n * `selectedTextTrackId` is cleared along with the deselected track's\n * `textBufferState` entry — setting mode to 'disabled' clears native cues from\n * the track element, so the buffer must be reset to re-fetch cues on re-enable.\n *\n * @example\n * const cleanup = syncSelectedTextTrackFromDom({ state, owners });\n */\nexport function syncSelectedTextTrackFromDom({\n  state,\n  owners,\n}: {\n  state: WritableState<SelectedTextTrackFromDomState>;\n  owners: WritableState<SelectedTextTrackFromDomOwners>;\n}): () => void {\n  let lastMediaElement: HTMLMediaElement | undefined;\n  let removeListener: (() => void) | null = null;\n\n  const unsubscribe = owners.subscribe((currentOwners) => {\n    const { mediaElement } = currentOwners;\n\n    if (mediaElement === lastMediaElement) return;\n\n    removeListener?.();\n    removeListener = null;\n    lastMediaElement = mediaElement;\n\n    if (!mediaElement) return;\n\n    const sync = () => {\n      const showingTrack = Array.from(mediaElement.textTracks).find(\n        (t) => t.mode === 'showing' && (t.kind === 'subtitles' || t.kind === 'captions')\n      );\n\n      // showingTrack.id is set from the SPF presentation track ID by setupTextTracks.\n      // Fall back to undefined for empty-string IDs (non-SPF-managed tracks).\n      const newId = showingTrack?.id || undefined;\n      const current = state.current;\n\n      // Guard against redundant patches — e.g. syncTextTrackModes confirming the\n      // current selection, which would otherwise create a feedback loop.\n      if (current.selectedTextTrackId === newId) return;\n\n      if (newId) {\n        state.patch({ selectedTextTrackId: newId });\n      } else {\n        // When deselecting, clear the textBufferState entry for the previous track.\n        // Setting mode to 'disabled' (as toggleSubtitles() does) clears native cues\n        // from the track element, so the buffer must be reset to allow re-fetching\n        // on re-enable.\n        const prevId = current.selectedTextTrackId;\n        if (prevId && current.textBufferState?.[prevId]) {\n          const next = { ...current.textBufferState };\n          delete next[prevId];\n          state.patch({ selectedTextTrackId: undefined, textBufferState: next });\n        } else {\n          state.patch({ selectedTextTrackId: undefined });\n        }\n      }\n    };\n\n    removeListener = listen(mediaElement.textTracks, 'change', sync);\n  });\n\n  return () => {\n    removeListener?.();\n    unsubscribe();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,6BAA6B,EAC3C,OACA,UAIa;CACb,IAAI;CACJ,IAAI,iBAAsC;CAE1C,MAAM,cAAc,OAAO,WAAW,kBAAkB;EACtD,MAAM,EAAE,iBAAiB;AAEzB,MAAI,iBAAiB,iBAAkB;AAEvC,oBAAkB;AAClB,mBAAiB;AACjB,qBAAmB;AAEnB,MAAI,CAAC,aAAc;EAEnB,MAAM,aAAa;GAOjB,MAAM,QANe,MAAM,KAAK,aAAa,WAAW,CAAC,MACtD,MAAM,EAAE,SAAS,cAAc,EAAE,SAAS,eAAe,EAAE,SAAS,YACtE,EAI2B,MAAM;GAClC,MAAM,UAAU,MAAM;AAItB,OAAI,QAAQ,wBAAwB,MAAO;AAE3C,OAAI,MACF,OAAM,MAAM,EAAE,qBAAqB,OAAO,CAAC;QACtC;IAKL,MAAM,SAAS,QAAQ;AACvB,QAAI,UAAU,QAAQ,kBAAkB,SAAS;KAC/C,MAAM,OAAO,EAAE,GAAG,QAAQ,iBAAiB;AAC3C,YAAO,KAAK;AACZ,WAAM,MAAM;MAAE,qBAAqB;MAAW,iBAAiB;MAAM,CAAC;UAEtE,OAAM,MAAM,EAAE,qBAAqB,QAAW,CAAC;;;AAKrD,mBAAiB,OAAO,aAAa,YAAY,UAAU,KAAK;GAChE;AAEF,cAAa;AACX,oBAAkB;AAClB,eAAa"}

package/dist/dev/dom/features/sync-text-track-modes.js

@@ -0,0 +1,38 @@
+import { combineLatest } from "../../core/reactive/combine-latest.js";
+
+//#region src/dom/features/sync-text-track-modes.ts
+/**
+* Check if we can sync text track modes.
+*
+* Requires:
+* - textTracks map exists (track elements created)
+*/
+function canSyncTextTrackModes(owners) {
+	return !!owners.textTracks && owners.textTracks.size > 0;
+}
+/**
+* Sync text track modes orchestration.
+*
+* Manages track element modes based on selectedTextTrackId:
+* - Selected track: mode = "showing"
+* - Other tracks: mode = "hidden"
+* - No selection: all tracks mode = "hidden"
+*
+* Note: Uses "hidden" instead of "disabled" for non-selected tracks
+* so they remain available in the browser's track menu.
+*
+* @example
+* const cleanup = syncTextTrackModes({ state, owners });
+*/
+function syncTextTrackModes({ state, owners }) {
+	return combineLatest([state, owners]).subscribe(([s, o]) => {
+		if (!canSyncTextTrackModes(o)) return;
+		const selectedId = s.selectedTextTrackId;
+		for (const [trackId, trackElement] of o.textTracks) if (trackId === selectedId) trackElement.track.mode = "showing";
+		else trackElement.track.mode = "hidden";
+	});
+}
+
+//#endregion
+export { syncTextTrackModes };
+//# sourceMappingURL=sync-text-track-modes.js.map

package/dist/dev/dom/features/sync-text-track-modes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-text-track-modes.js","names":[],"sources":["../../../../src/dom/features/sync-text-track-modes.ts"],"sourcesContent":["import { combineLatest } from '../../core/reactive/combine-latest';\nimport type { WritableState } from '../../core/state/create-state';\n\n/**\n * State shape for text track mode synchronization.\n */\nexport interface TextTrackModeState {\n  selectedTextTrackId?: string | undefined;\n}\n\n/**\n * Owners shape for text track mode synchronization.\n */\nexport interface TextTrackModeOwners {\n  textTracks?: Map<string, HTMLTrackElement>;\n}\n\n/**\n * Check if we can sync text track modes.\n *\n * Requires:\n * - textTracks map exists (track elements created)\n */\nexport function canSyncTextTrackModes(owners: TextTrackModeOwners): boolean {\n  return !!owners.textTracks && owners.textTracks.size > 0;\n}\n\n/**\n * Sync text track modes orchestration.\n *\n * Manages track element modes based on selectedTextTrackId:\n * - Selected track: mode = \"showing\"\n * - Other tracks: mode = \"hidden\"\n * - No selection: all tracks mode = \"hidden\"\n *\n * Note: Uses \"hidden\" instead of \"disabled\" for non-selected tracks\n * so they remain available in the browser's track menu.\n *\n * @example\n * const cleanup = syncTextTrackModes({ state, owners });\n */\nexport function syncTextTrackModes({\n  state,\n  owners,\n}: {\n  state: WritableState<TextTrackModeState>;\n  owners: WritableState<TextTrackModeOwners>;\n}): () => void {\n  return combineLatest([state, owners]).subscribe(([s, o]: [TextTrackModeState, TextTrackModeOwners]) => {\n    // Check orchestration conditions\n    if (!canSyncTextTrackModes(o)) return;\n\n    const selectedId = s.selectedTextTrackId;\n\n    // Update all track element modes\n    for (const [trackId, trackElement] of o.textTracks!) {\n      if (trackId === selectedId) {\n        // Selected track: show it\n        trackElement.track.mode = 'showing';\n      } else {\n        // Other tracks: hide them (but keep available in menu)\n        trackElement.track.mode = 'hidden';\n      }\n    }\n  });\n}\n"],"mappings":";;;;;;;;;AAuBA,SAAgB,sBAAsB,QAAsC;AAC1E,QAAO,CAAC,CAAC,OAAO,cAAc,OAAO,WAAW,OAAO;;;;;;;;;;;;;;;;AAiBzD,SAAgB,mBAAmB,EACjC,OACA,UAIa;AACb,QAAO,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC,WAAW,CAAC,GAAG,OAAkD;AAErG,MAAI,CAAC,sBAAsB,EAAE,CAAE;EAE/B,MAAM,aAAa,EAAE;AAGrB,OAAK,MAAM,CAAC,SAAS,iBAAiB,EAAE,WACtC,KAAI,YAAY,WAEd,cAAa,MAAM,OAAO;MAG1B,cAAa,MAAM,OAAO;GAG9B"}