@videojs/spf 10.0.0-beta.10 → 10.0.0-beta.12

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

@@ -0,0 +1,196 @@
+import { calculateForwardFlushPoint, getSegmentsToLoad } from "../../core/buffer/forward-buffer.js";
+import { calculateBackBufferFlushPoint } from "../../core/buffer/back-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.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 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.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;
+	};
+	/**
+	* 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/default/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(\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 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.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  /**\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":";;;;;;;;;;;;;;;;;;;;AA2GA,SAAgB,yBACd,mBACA,YAIoB;CACpB,IAAI,eAAkC;CACtC,IAAI,sBAAqC;CACzC,IAAI,oBAAmC;CACvC,IAAI,kBAA0C;CAC9C,IAAI,UAAU;CACd,IAAI,YAAY;CAEhB,MAAM,uBAAuB,gBAA+C;EAG1E,MAAM,cAAc,IAAI,IACtB,kBAAkB,SACf,KAAK,CACL,QAAQ,SAAS,QAAQ,MAAM,CAAC,EAAE,QAAQ,CAC1C,KAAK,MAAM,EAAE,GAAG,CACpB;AACD,SAAO,YAAY,QAAQ,MAAM,YAAY,IAAI,EAAE,GAAG,CAAC;;;;;;;;;;;;;;;;;CAkBzD,MAAM,aAAa,YAA8C;EAC/D,MAAM,EAAE,OAAO,UAAU;EACzB,MAAM,WAAW,kBAAkB,SAAS,KAAK,CAAC;EAClD,MAAM,mBAAmB,oBAAoB,MAAM,SAAS;EAC5D,MAAM,cAAc,OAAO,SAAS;EACpC,MAAM,QAAoB,EAAE;AAG5B,MAAI,OAAO;GACT,MAAM,oBAAoB,2BAA2B,kBAAkB,YAAY;AACnF,OAAI,oBAAoB,SACtB,OAAM,KAAK;IAAE,MAAM;IAAU,OAAO;IAAmB,KAAK;IAAU,CAAC;GAEzE,MAAM,eAAe,8BAA8B,kBAAkB,YAAY;AACjF,OAAI,eAAe,EACjB,OAAM,KAAK;IAAE,MAAM;IAAU,OAAO;IAAG,KAAK;IAAc,CAAC;;AAK/D,MAAI,SAAS,gBAAgB,MAAM,GACjC,OAAM,KAAK;GACT,MAAM;GACN,MAAM,EAAE,SAAS,MAAM,IAAI;GAC3B,KAAK,MAAM,eAAe;GAC1B,GAAI,MAAM,eAAe,cAAc,KAAA,KAAa,EAAE,WAAW,MAAM,eAAe,WAAW;GAClG,CAAC;AAIJ,MAAI,OAAO;GACT,MAAM,UAAU;GAChB,MAAM,iBAAiB,kBAAkB,MAAM,UAAU,kBAAkB,YAAY,CAAC,QAAQ,QAAQ;IAItG,MAAM,WAAW,SAAS,SAAS,MAAM,MAAM,KAAK,IAAI,EAAE,YAAY,IAAI,UAAU,GAAG,QAAQ;AAG/F,QAAI,UAAU,QAAS,QAAO;AAC9B,QAAI,CAAC,UAAU,kBAAkB,CAAC,MAAM,UAAW,QAAO;AAC1D,WAAO,MAAM,YAAY,SAAS;KAClC;AACF,QAAK,MAAM,WAAW,eACpB,OAAM,KAAK;IACT,MAAM;IACN,MAAM;KACJ,IAAI,QAAQ;KACZ,WAAW,QAAQ;KACnB,UAAU,QAAQ;KAClB,SAAS,MAAM;KACf,gBAAgB,MAAM;KACvB;IACD,KAAK,QAAQ;IACb,GAAI,QAAQ,cAAc,KAAA,KAAa,EAAE,WAAW,QAAQ,WAAW;IACxE,CAAC;;AAIN,SAAO;;;;;;;;;CAUT,MAAM,kBAAkB,OAAO,SAAkC;EAC/D,MAAM,SAAS,gBAAiB;AAChC,MAAI;AACF,OAAI,KAAK,SAAS,UAAU;AAC1B,UAAM,kBAAkB,KAAK,MAAM,OAAO;AAC1C;;AAGF,OAAI,KAAK,SAAS,eAAe;AAC/B,0BAAsB,KAAK,KAAK;AAChC,QAAI,CAAC,OAAO,SAAS;KAMnB,MAAM,OAAO,MAAM,WAAW,MAAM;MAAE;MAAQ,cAAc;MAAU,CAAC;KAIvE,MAAM,gBAAgB,cAAc,MACjC,MAAM,EAAE,SAAS,iBAAiB,EAAE,KAAK,YAAY,KAAK,KAAK,QACjE;AACD,SAAI,CAAC,OAAO,WAAW,CAAC,eAAe;MACrC,MAAM,eAAe,OAAO,UAAU,IAAI,iBAAiB,CAAC,SAAS;AACrE,YAAM,kBAAkB,KAAK;OAAE,MAAM;OAAe;OAAM,MAAM,KAAK;OAAM,EAAE,aAAa;;;AAG9F;;AAMF,uBAAoB,KAAK,KAAK;AAC9B,OAAI,CAAC,OAAO,SAAS;IACnB,MAAM,SAAS,MAAM,WAAW,MAAM,EAAE,QAAQ,CAAC;AACjD,QAAI,CAAC,OAAO,QACV,OAAM,kBAAkB,KAAK;KAAE,MAAM;KAAkB,MAAM;KAAQ,MAAM,KAAK;KAAM,EAAE,OAAO;;YAG3F;AACR,yBAAsB;AACtB,uBAAoB;;;;;;;;CASxB,MAAM,eAAe,OAAO,iBAA4C;AACtE,YAAU;AACV,oBAAkB,IAAI,iBAAiB;EACvC,IAAI,YAAY;AAEhB,SAAO,UAAU,SAAS,KAAK,CAAC,WAAW;GACzC,MAAM,OAAO,UAAU;AACvB,eAAY,UAAU,MAAM,EAAE;AAE9B,OAAI;AACF,UAAM,gBAAgB,KAAK;YACpB,OAAO;AACd,QAAI,iBAAiB,SAAS,MAAM,SAAS,cAAc,QAEpD;AACL,aAAQ,MAAM,uCAAuC,MAAM;AAI3D,iBAAY,EAAE;;;AAIlB,OAAI,iBAAiB,MAAM;AAEzB,gBAAY;AACZ,mBAAe;AACf,sBAAkB,IAAI,iBAAiB;cAC9B,gBAAgB,OAAO,QAEhC;;AAIJ,oBAAkB;AAClB,YAAU;;AAGZ,QAAO;EACL,KAAK,SAA+B;AAClC,OAAI,UAAW;GAEf,MAAM,WAAW,UAAU,QAAQ;AAEnC,OAAI,CAAC,SAAS;AACZ,QAAI,SAAS,WAAW,EAAG;AAC3B,iBAAa,SAAS;AACtB;;AAUF,OALG,sBAAsB,QACrB,SAAS,MAAM,MAAM,EAAE,SAAS,oBAAoB,EAAE,KAAK,OAAO,kBAAkB,IACrF,wBAAwB,QACvB,SAAS,MAAM,MAAM,EAAE,SAAS,iBAAiB,EAAE,KAAK,YAAY,oBAAoB,CAK1F,gBAAe,SAAS,QACrB,MACC,EAAE,EAAE,SAAS,oBAAoB,EAAE,KAAK,OAAO,sBAC/C,EAAE,EAAE,SAAS,iBAAiB,EAAE,KAAK,YAAY,qBACpD;QACI;AAEL,mBAAe;AACf,qBAAiB,OAAO;;;EAI5B,UAAU;AACR,eAAY;AACZ,oBAAiB,OAAO;;EAE3B"}

package/dist/default/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/default/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/default/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/default/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"}

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

@@ -0,0 +1,67 @@
+import { effect } from "../../core/signals/effect.js";
+import { computed, update } from "../../core/signals/primitives.js";
+//#region src/dom/features/setup-text-tracks.ts
+/**
+* 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 }) {
+	const modelTextTracksSignal = computed(() => state.get().presentation?.selectionSets?.find((selectionSet) => selectionSet.type === "text")?.switchingSets[0]?.tracks, { equals(prevTextTracks, nextTextTracks) {
+		if (prevTextTracks === nextTextTracks) return true;
+		if (typeof prevTextTracks !== typeof nextTextTracks) return false;
+		if (prevTextTracks?.length !== nextTextTracks?.length) return false;
+		return !!nextTextTracks && nextTextTracks.every((nextTextTrack) => prevTextTracks?.some((prevTextTrack) => prevTextTrack.id === nextTextTrack.id));
+	} });
+	const ownerTextTracksSignal = computed(() => owners.get().textTracks);
+	const mediaElementSignal = computed(() => owners.get().mediaElement);
+	const canSetupTextTracksSignal = computed(() => !!mediaElementSignal.get() && modelTextTracksSignal.get()?.length);
+	const shouldSetupTextTracksSignal = computed(() => !ownerTextTracksSignal.get());
+	const cleanupEffect = effect(() => {
+		if (!canSetupTextTracksSignal.get() || !shouldSetupTextTracksSignal.get()) return;
+		const mediaElement = mediaElementSignal.get();
+		const modelTextTracks = modelTextTracksSignal.get();
+		const trackMap = /* @__PURE__ */ new Map();
+		modelTextTracks.forEach((modelTextTrack) => {
+			const trackElement = createTrackElement(modelTextTrack);
+			mediaElement.appendChild(trackElement);
+			trackMap.set(modelTextTrack.id, trackElement);
+		});
+		if (trackMap.size) update(owners, { textTracks: trackMap });
+	});
+	return () => {
+		owners.get().textTracks?.forEach((trackElement) => trackElement.remove());
+		cleanupEffect();
+	};
+}
+//#endregion
+export { setupTextTracks };
+
+//# sourceMappingURL=setup-text-tracks.js.map

package/dist/default/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 { effect } from '../../core/signals/effect';\nimport { computed, type Signal, update } from '../../core/signals/primitives';\nimport type { PartiallyResolvedTextTrack, Presentation, TextTrack } 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 * 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 | TextTrack): 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<S extends TextTrackState, O extends TextTrackOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  const modelTextTracksSignal = computed(\n    // NOTE: This assumes exactly one selection set and switching set for TextTracks (CJP)\n    () =>\n      state.get().presentation?.selectionSets?.find((selectionSet) => selectionSet.type === 'text')?.switchingSets[0]\n        ?.tracks,\n    {\n      /** @TODO Make generic and abstract away for Array<T> | undefined (CJP) */\n      equals(prevTextTracks, nextTextTracks) {\n        if (prevTextTracks === nextTextTracks) return true;\n        if (typeof prevTextTracks !== typeof nextTextTracks) return false;\n        if (prevTextTracks?.length !== nextTextTracks?.length) return false;\n        // NOTE: This could probably be optimized, but the set should generally be small (CJP)\n        return (\n          !!nextTextTracks &&\n          nextTextTracks.every((nextTextTrack) =>\n            prevTextTracks?.some((prevTextTrack) => prevTextTrack.id === nextTextTrack.id)\n          )\n        );\n      },\n    }\n  );\n  const ownerTextTracksSignal = computed(() => owners.get().textTracks);\n  const mediaElementSignal = computed(() => owners.get().mediaElement);\n\n  const canSetupTextTracksSignal = computed(() => !!mediaElementSignal.get() && modelTextTracksSignal.get()?.length);\n  const shouldSetupTextTracksSignal = computed(() => !ownerTextTracksSignal.get());\n\n  const cleanupEffect = effect(() => {\n    if (!canSetupTextTracksSignal.get() || !shouldSetupTextTracksSignal.get()) return;\n    const mediaElement = mediaElementSignal.get();\n    const modelTextTracks = modelTextTracksSignal.get() as TextTrack[];\n\n    const trackMap = new Map<string, HTMLTrackElement>();\n    modelTextTracks.forEach((modelTextTrack) => {\n      const trackElement = createTrackElement(modelTextTrack);\n      mediaElement!.appendChild(trackElement);\n      trackMap.set(modelTextTrack.id, trackElement);\n    });\n\n    if (trackMap.size) {\n      const patch: Partial<TextTrackOwners> = { textTracks: trackMap };\n      update(owners, patch);\n    }\n  });\n\n  return () => {\n    owners.get().textTracks?.forEach((trackElement) => trackElement.remove());\n    cleanupEffect();\n  };\n}\n"],"mappings":";;;;;;;;;AA0BA,SAAS,mBAAmB,OAAiE;CAC3F,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,gBAAqE,EACnF,OACA,UAIa;CACb,MAAM,wBAAwB,eAG1B,MAAM,KAAK,CAAC,cAAc,eAAe,MAAM,iBAAiB,aAAa,SAAS,OAAO,EAAE,cAAc,IACzG,QACN,EAEE,OAAO,gBAAgB,gBAAgB;AACrC,MAAI,mBAAmB,eAAgB,QAAO;AAC9C,MAAI,OAAO,mBAAmB,OAAO,eAAgB,QAAO;AAC5D,MAAI,gBAAgB,WAAW,gBAAgB,OAAQ,QAAO;AAE9D,SACE,CAAC,CAAC,kBACF,eAAe,OAAO,kBACpB,gBAAgB,MAAM,kBAAkB,cAAc,OAAO,cAAc,GAAG,CAC/E;IAGN,CACF;CACD,MAAM,wBAAwB,eAAe,OAAO,KAAK,CAAC,WAAW;CACrE,MAAM,qBAAqB,eAAe,OAAO,KAAK,CAAC,aAAa;CAEpE,MAAM,2BAA2B,eAAe,CAAC,CAAC,mBAAmB,KAAK,IAAI,sBAAsB,KAAK,EAAE,OAAO;CAClH,MAAM,8BAA8B,eAAe,CAAC,sBAAsB,KAAK,CAAC;CAEhF,MAAM,gBAAgB,aAAa;AACjC,MAAI,CAAC,yBAAyB,KAAK,IAAI,CAAC,4BAA4B,KAAK,CAAE;EAC3E,MAAM,eAAe,mBAAmB,KAAK;EAC7C,MAAM,kBAAkB,sBAAsB,KAAK;EAEnD,MAAM,2BAAW,IAAI,KAA+B;AACpD,kBAAgB,SAAS,mBAAmB;GAC1C,MAAM,eAAe,mBAAmB,eAAe;AACvD,gBAAc,YAAY,aAAa;AACvC,YAAS,IAAI,eAAe,IAAI,aAAa;IAC7C;AAEF,MAAI,SAAS,KAEX,QAAO,QADiC,EAAE,YAAY,UAAU,CAC3C;GAEvB;AAEF,cAAa;AACX,SAAO,KAAK,CAAC,YAAY,SAAS,iBAAiB,aAAa,QAAQ,CAAC;AACzE,iBAAe"}

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

@@ -0,0 +1,54 @@
+import { effect } from "../../core/signals/effect.js";
+import { computed, update } from "../../core/signals/primitives.js";
+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 }) {
+	const mediaElement = computed(() => owners.get().mediaElement);
+	return effect(() => {
+		const el = mediaElement.get();
+		if (!el) return;
+		return listen(el.textTracks, "change", () => {
+			const newId = Array.from(el.textTracks).find((t) => t.mode === "showing" && (t.kind === "subtitles" || t.kind === "captions"))?.id || void 0;
+			const current = state.get();
+			if (current.selectedTextTrackId === newId) return;
+			if (newId) update(state, { selectedTextTrackId: newId });
+			else {
+				const prevId = current.selectedTextTrackId;
+				if (prevId && current.textBufferState?.[prevId]) {
+					const next = { ...current.textBufferState };
+					delete next[prevId];
+					update(state, {
+						selectedTextTrackId: void 0,
+						textBufferState: next
+					});
+				} else update(state, { selectedTextTrackId: void 0 });
+			}
+		});
+	});
+}
+//#endregion
+export { syncSelectedTextTrackFromDom };
+
+//# sourceMappingURL=sync-selected-text-track-from-dom.js.map

package/dist/default/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 { effect } from '../../core/signals/effect';\nimport { computed, type Signal, update } from '../../core/signals/primitives';\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  S extends SelectedTextTrackFromDomState,\n  O extends SelectedTextTrackFromDomOwners,\n>({ state, owners }: { state: Signal<S>; owners: Signal<O> }): () => void {\n  const mediaElement = computed(() => owners.get().mediaElement);\n\n  return effect(() => {\n    const el = mediaElement.get();\n    if (!el) return;\n\n    return listen(el.textTracks, 'change', () => {\n      const showingTrack = Array.from(el.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.get();\n\n      // Guard against redundant writes — 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        const patch: Partial<SelectedTextTrackFromDomState> = { selectedTextTrackId: newId };\n        update(state, patch);\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          const patch: Partial<SelectedTextTrackFromDomState> = {\n            selectedTextTrackId: undefined,\n            textBufferState: next,\n          };\n          update(state, patch);\n        } else {\n          const patch: Partial<SelectedTextTrackFromDomState> = { selectedTextTrackId: undefined };\n          update(state, patch);\n        }\n      }\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,6BAGd,EAAE,OAAO,UAA+D;CACxE,MAAM,eAAe,eAAe,OAAO,KAAK,CAAC,aAAa;AAE9D,QAAO,aAAa;EAClB,MAAM,KAAK,aAAa,KAAK;AAC7B,MAAI,CAAC,GAAI;AAET,SAAO,OAAO,GAAG,YAAY,gBAAgB;GAO3C,MAAM,QANe,MAAM,KAAK,GAAG,WAAW,CAAC,MAC5C,MAAM,EAAE,SAAS,cAAc,EAAE,SAAS,eAAe,EAAE,SAAS,YACtE,EAI2B,MAAM,KAAA;GAClC,MAAM,UAAU,MAAM,KAAK;AAI3B,OAAI,QAAQ,wBAAwB,MAAO;AAE3C,OAAI,MAEF,QAAO,OAD+C,EAAE,qBAAqB,OAAO,CAChE;QACf;IAKL,MAAM,SAAS,QAAQ;AACvB,QAAI,UAAU,QAAQ,kBAAkB,SAAS;KAC/C,MAAM,OAAO,EAAE,GAAG,QAAQ,iBAAiB;AAC3C,YAAO,KAAK;AAKZ,YAAO,OAJ+C;MACpD,qBAAqB,KAAA;MACrB,iBAAiB;MAClB,CACmB;UAGpB,QAAO,OAD+C,EAAE,qBAAqB,KAAA,GAAW,CACpE;;IAGxB;GACF"}

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

@@ -0,0 +1,33 @@
+import { effect } from "../../core/signals/effect.js";
+import { computed } from "../../core/signals/primitives.js";
+//#region src/dom/features/sync-text-track-modes.ts
+/**
+* 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 }) {
+	const textTracksSignal = computed(() => owners.get().textTracks);
+	const selectedTextTrackIdSignal = computed(() => state.get().selectedTextTrackId);
+	const canSyncTextTrackModes = computed(() => !!textTracksSignal.get()?.size);
+	return effect(() => {
+		if (!canSyncTextTrackModes.get()) return;
+		/** @TODO refactor TextTracks owners model. Should simply use id. Also should use corresponding TextTrack (JS) element if possible (CJP) */
+		const textTracks = textTracksSignal.get();
+		const selectedTextTrackId = selectedTextTrackIdSignal.get();
+		for (const [trackId, trackElement] of textTracks) trackElement.track.mode = trackId === selectedTextTrackId ? "showing" : "hidden";
+	});
+}
+//#endregion
+export { syncTextTrackModes };
+
+//# sourceMappingURL=sync-text-track-modes.js.map

package/dist/default/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 { effect } from '../../core/signals/effect';\nimport { computed, type Signal } from '../../core/signals/primitives';\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 * 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<S extends TextTrackModeState, O extends TextTrackModeOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  const textTracksSignal = computed(() => owners.get().textTracks);\n  const selectedTextTrackIdSignal = computed(() => state.get().selectedTextTrackId);\n\n  const canSyncTextTrackModes = computed(() => !!textTracksSignal.get()?.size);\n\n  return effect(() => {\n    if (!canSyncTextTrackModes.get()) return;\n    /** @TODO refactor TextTracks owners model. Should simply use id. Also should use corresponding TextTrack (JS) element if possible (CJP) */\n    const textTracks = textTracksSignal.get() as Map<string, HTMLTrackElement>;\n    const selectedTextTrackId = selectedTextTrackIdSignal.get() as string;\n\n    for (const [trackId, trackElement] of textTracks) {\n      trackElement.track.mode = trackId === selectedTextTrackId ? 'showing' : 'hidden';\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA+BA,SAAgB,mBAAgF,EAC9F,OACA,UAIa;CACb,MAAM,mBAAmB,eAAe,OAAO,KAAK,CAAC,WAAW;CAChE,MAAM,4BAA4B,eAAe,MAAM,KAAK,CAAC,oBAAoB;CAEjF,MAAM,wBAAwB,eAAe,CAAC,CAAC,iBAAiB,KAAK,EAAE,KAAK;AAE5E,QAAO,aAAa;AAClB,MAAI,CAAC,sBAAsB,KAAK,CAAE;;EAElC,MAAM,aAAa,iBAAiB,KAAK;EACzC,MAAM,sBAAsB,0BAA0B,KAAK;AAE3D,OAAK,MAAM,CAAC,SAAS,iBAAiB,WACpC,cAAa,MAAM,OAAO,YAAY,sBAAsB,YAAY;GAE1E"}

package/dist/default/dom/features/track-current-time.js

@@ -0,0 +1,49 @@
+import { effect } from "../../core/signals/effect.js";
+import { update } from "../../core/signals/primitives.js";
+import { listen } from "@videojs/utils/dom";
+//#region src/dom/features/track-current-time.ts
+/**
+* Track current playback position from the media element.
+*
+* Mirrors `mediaElement.currentTime` into reactive state on:
+* - `timeupdate` — fires during playback (~4 Hz)
+* - `seeking` — fires when a seek begins; per spec, `currentTime` is
+*   already at the new position when this event dispatches, so buffer
+*   management can react immediately rather than waiting for `timeupdate`,
+*   which does not fire while paused.
+*
+* Also syncs immediately when a media element becomes available.
+*
+* @example
+* const cleanup = trackCurrentTime({ state, owners });
+*/
+function trackCurrentTime({ state, owners }) {
+	let lastMediaElement;
+	let removeListeners = null;
+	const cleanupEffect = effect(() => {
+		const { mediaElement } = owners.get();
+		if (mediaElement === lastMediaElement) return;
+		removeListeners?.();
+		removeListeners = null;
+		lastMediaElement = mediaElement;
+		if (!mediaElement) return;
+		const sync = () => {
+			update(state, { currentTime: mediaElement.currentTime });
+		};
+		sync();
+		const removeTimeupdate = listen(mediaElement, "timeupdate", sync);
+		const removeSeeking = listen(mediaElement, "seeking", sync);
+		removeListeners = () => {
+			removeTimeupdate();
+			removeSeeking();
+		};
+	});
+	return () => {
+		removeListeners?.();
+		cleanupEffect();
+	};
+}
+//#endregion
+export { trackCurrentTime };
+
+//# sourceMappingURL=track-current-time.js.map

package/dist/default/dom/features/track-current-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-current-time.js","names":[],"sources":["../../../../src/dom/features/track-current-time.ts"],"sourcesContent":["import { listen } from '@videojs/utils/dom';\nimport { effect } from '../../core/signals/effect';\nimport { type Signal, update } from '../../core/signals/primitives';\n\n/**\n * State shape for current time tracking.\n */\nexport interface CurrentTimeState {\n  currentTime?: number;\n}\n\n/**\n * Owners shape for current time tracking.\n */\nexport interface CurrentTimeOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\n/**\n * Check if we can track current time.\n *\n * Requires:\n * - mediaElement exists in owners\n */\nexport function canTrackCurrentTime(owners: CurrentTimeOwners): boolean {\n  return !!owners.mediaElement;\n}\n\n/**\n * Track current playback position from the media element.\n *\n * Mirrors `mediaElement.currentTime` into reactive state on:\n * - `timeupdate` — fires during playback (~4 Hz)\n * - `seeking` — fires when a seek begins; per spec, `currentTime` is\n *   already at the new position when this event dispatches, so buffer\n *   management can react immediately rather than waiting for `timeupdate`,\n *   which does not fire while paused.\n *\n * Also syncs immediately when a media element becomes available.\n *\n * @example\n * const cleanup = trackCurrentTime({ state, owners });\n */\nexport function trackCurrentTime<S extends CurrentTimeState, O extends CurrentTimeOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  let lastMediaElement: HTMLMediaElement | undefined;\n  let removeListeners: (() => void) | null = null;\n\n  const cleanupEffect = effect(() => {\n    const { mediaElement } = owners.get();\n\n    if (mediaElement === lastMediaElement) return;\n\n    removeListeners?.();\n    removeListeners = null;\n    lastMediaElement = mediaElement;\n\n    if (!mediaElement) return;\n\n    const sync = () => {\n      const patch: Partial<CurrentTimeState> = { currentTime: mediaElement.currentTime };\n      update(state, patch);\n    };\n\n    // Sync immediately so consumers don't wait for the first event\n    sync();\n    const removeTimeupdate = listen(mediaElement, 'timeupdate', sync);\n    const removeSeeking = listen(mediaElement, 'seeking', sync);\n    removeListeners = () => {\n      removeTimeupdate();\n      removeSeeking();\n    };\n  });\n\n  return () => {\n    removeListeners?.();\n    cleanupEffect();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,iBAA0E,EACxF,OACA,UAIa;CACb,IAAI;CACJ,IAAI,kBAAuC;CAE3C,MAAM,gBAAgB,aAAa;EACjC,MAAM,EAAE,iBAAiB,OAAO,KAAK;AAErC,MAAI,iBAAiB,iBAAkB;AAEvC,qBAAmB;AACnB,oBAAkB;AAClB,qBAAmB;AAEnB,MAAI,CAAC,aAAc;EAEnB,MAAM,aAAa;AAEjB,UAAO,OADkC,EAAE,aAAa,aAAa,aAAa,CAC9D;;AAItB,QAAM;EACN,MAAM,mBAAmB,OAAO,cAAc,cAAc,KAAK;EACjE,MAAM,gBAAgB,OAAO,cAAc,WAAW,KAAK;AAC3D,0BAAwB;AACtB,qBAAkB;AAClB,kBAAe;;GAEjB;AAEF,cAAa;AACX,qBAAmB;AACnB,iBAAe"}