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

package/dist/dev/dom/features/load-segments.d.ts

@@ -0,0 +1,72 @@
+import { BandwidthState } from "../../core/abr/bandwidth-estimator.js";
+import { WritableState } from "../../core/state/create-state.js";
+import { Presentation } from "../../core/types/index.js";
+import { TrackSelectionState } from "../../core/utils/track-selection.js";
+import { SourceBufferActor } from "../media/source-buffer-actor.js";
+import { MediaTrackType } from "./setup-sourcebuffer.js";
+
+//#region src/dom/features/load-segments.d.ts
+/**
+ * State shape for segment loading.
+ */
+interface SegmentLoadingState extends TrackSelectionState {
+  presentation?: Presentation;
+  preload?: string;
+  bandwidthState?: BandwidthState;
+  /** Current playback position in seconds. Defaults to 0 when undefined. */
+  currentTime?: number;
+  /** True once the user has initiated playback. Allows segment loading regardless of preload setting. */
+  playbackInitiated?: boolean;
+}
+/**
+ * Owners shape for segment loading.
+ */
+interface SegmentLoadingOwners {
+  videoBuffer?: SourceBuffer;
+  audioBuffer?: SourceBuffer;
+  videoBufferActor?: SourceBufferActor;
+  audioBufferActor?: SourceBufferActor;
+}
+/**
+ * Load segments orchestration — Reactor layer.
+ *
+ * Sends typed load messages to a SegmentLoaderActor when relevant conditions
+ * change. Uses targeted subscriptions rather than broad combineLatest so only
+ * meaningful state changes trigger evaluation.
+ *
+ * Condition hierarchy (see SegmentLoadingKey for detail):
+ *
+ *   !playbackInitiated
+ *     preload==='none' (or unset)  → dormant; no trigger
+ *     preload==='metadata'         → trigger on transition to 'metadata'
+ *     preload==='auto'             → trigger on transition to 'auto'
+ *
+ *   !playbackInitiated → playbackInitiated
+ *     preload !== 'auto'           → trigger (message shape changes)
+ *     preload === 'auto'           → suppressed (was already full-range mode;
+ *                                    let segmentStart take over post-play)
+ *                                    KNOWN LIMITATION: seek-before-play with
+ *                                    preload='auto' is not supported — if the
+ *                                    user seeks before pressing play, the
+ *                                    first re-send is delayed until the next
+ *                                    segment boundary crossing post-play.
+ *
+ *   playbackInitiated
+ *     resolvedTrackId changes      → trigger
+ *     segmentStart(currentTime) changes → trigger (segment boundary only)
+ *
+ * @example
+ * const cleanup = loadSegments({ state, owners }, { type: 'video' });
+ */
+declare function loadSegments({
+  state,
+  owners
+}: {
+  state: WritableState<SegmentLoadingState>;
+  owners: WritableState<SegmentLoadingOwners>;
+}, config: {
+  type: MediaTrackType;
+}): () => void;
+//#endregion
+export { loadSegments };
+//# sourceMappingURL=load-segments.d.ts.map

package/dist/dev/dom/features/load-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-segments.d.ts","names":[],"sources":["../../../../src/dom/features/load-segments.ts"],"mappings":";;;;;;;;AA8FA;;;AAAA,UAAiB,mBAAA,SAA4B,mBAAA;EAC3C,YAAA,GAAe,YAAA;EACf,OAAA;EACA,cAAA,GAAiB,cAAA;EAH6C;EAK9D,WAAA;EAJA;EAMA,iBAAA;AAAA;;;;UAMe,oBAAA;EACf,WAAA,GAAc,YAAA;EACd,WAAA,GAAc,YAAA;EACd,gBAAA,GAAmB,iBAAA;EACnB,gBAAA,GAAmB,iBAAA;AAAA;;;;;;;;;;;;;;;;;AAgIrB;;;;;;;;;;;;;;;iBAAgB,YAAA,CAAA;EAEZ,KAAA;EACA;AAAA;EAEA,KAAA,EAAO,aAAA,CAAc,mBAAA;EACrB,MAAA,EAAQ,aAAA,CAAc,oBAAA;AAAA,GAExB,MAAA;EAAU,IAAA,EAAM,cAAA;AAAA"}

package/dist/dev/dom/features/load-segments.js

@@ -0,0 +1,188 @@
+import { createState } from "../../core/state/create-state.js";
+import { sampleBandwidth } from "../../core/abr/bandwidth-estimator.js";
+import { DEFAULT_FORWARD_BUFFER_CONFIG } from "../../core/buffer/forward-buffer.js";
+import { isResolvedTrack } from "../../core/types/index.js";
+import { ChunkedStreamIterable } from "../network/chunked-stream-iterable.js";
+import { fetchResolvable } from "../network/fetch.js";
+import { combineLatest } from "../../core/reactive/combine-latest.js";
+import "../../all.js";
+import { getSelectedTrack } from "../../core/utils/track-selection.js";
+import { createSegmentLoaderActor } from "./segment-loader-actor.js";
+
+//#region src/dom/features/load-segments.ts
+const ActorKeyByType = {
+	video: "videoBufferActor",
+	audio: "audioBufferActor"
+};
+function createTrackedFetch(throughput, onSample) {
+	return async (addressable, options) => {
+		const { minChunkSize, ...fetchOptions } = options ?? {};
+		const response = await fetchResolvable(addressable, fetchOptions);
+		if (!response.body) throw new Error("Response has no body");
+		const body = response.body;
+		return { [Symbol.asyncIterator]: async function* () {
+			let chunkStart = performance.now();
+			for await (const chunk of new ChunkedStreamIterable(body, ...minChunkSize !== void 0 ? [{ minChunkSize }] : [])) {
+				const elapsed = performance.now() - chunkStart;
+				const next = sampleBandwidth(throughput.current, elapsed, chunk.byteLength);
+				throughput.patch(next);
+				throughput.flush();
+				onSample?.(next);
+				yield chunk;
+				chunkStart = performance.now();
+			}
+		} };
+	};
+}
+/**
+* Non-tracking fetch: eagerly starts the request and returns the response body
+* as a lazy chunk iterable. Used for audio tracks which don't sample bandwidth.
+* Pass `minChunkSize: Infinity` to accumulate the full body as a single chunk
+* (equivalent to arrayBuffer() but through the same streaming path).
+*/
+async function fetchStream(addressable, options) {
+	const { minChunkSize, ...fetchOptions } = options ?? {};
+	const response = await fetchResolvable(addressable, fetchOptions);
+	if (!response.body) throw new Error("Response has no body");
+	return new ChunkedStreamIterable(response.body, ...minChunkSize !== void 0 ? [{ minChunkSize }] : []);
+}
+function selectLoadingInputs([segmentsCanLoad, state], type) {
+	const { playbackInitiated, preload, currentTime } = state;
+	return {
+		playbackInitiated,
+		preload,
+		currentTime,
+		track: getSelectedTrack(state, type),
+		segmentsCanLoad
+	};
+}
+/**
+* Equality function encoding the condition hierarchy for relevant changes.
+*
+* Pre-play (!playbackInitiated):
+*   Only preload changes matter. currentTime and resolvedTrackId are ignored
+*   (track changes not supported pre-play; currentTime value is used at
+*   trigger time but changes don't re-trigger).
+*
+* playbackInitiated transition:
+*   Always fires (handled in the subscriber; preload='auto' suppression
+*   applied there since equality functions have no memory of prior values).
+*
+* Post-play (playbackInitiated):
+*   resolvedTrackId changes (track switch or previously-unresolved track
+*   resolving) and currentTime changes both trigger. preload is irrelevant.
+*/
+const segmentStartFor = (currentTime, track) => {
+	if (currentTime == null) return void 0;
+	return track?.segments.find(({ startTime, duration }, i, segments) => currentTime >= startTime && (currentTime < startTime + duration || i === segments.length - 1))?.startTime;
+};
+/**
+* Returns true when the inputs are equal (no meaningful change — don't fire).
+* Returns false when the inputs differ in a way that requires a new message.
+*
+* This IS the shouldLoadSegments logic, expressed as an equality function.
+*/
+function loadingInputsEq(prevState, curState) {
+	if (!curState.segmentsCanLoad) return true;
+	if (!curState.playbackInitiated) {
+		if (curState.preload === "none") return true;
+		return curState.preload === prevState.preload;
+	}
+	if (!prevState.playbackInitiated && curState.playbackInitiated) {
+		if (prevState.preload !== "auto") return false;
+	}
+	if (!curState.track || !isResolvedTrack(curState.track)) return true;
+	if (prevState.track?.id !== curState.track.id && isResolvedTrack(curState.track)) return false;
+	return segmentStartFor(prevState.currentTime, curState.track) === segmentStartFor(curState.currentTime, curState.track);
+}
+/**
+* Load segments orchestration — Reactor layer.
+*
+* Sends typed load messages to a SegmentLoaderActor when relevant conditions
+* change. Uses targeted subscriptions rather than broad combineLatest so only
+* meaningful state changes trigger evaluation.
+*
+* Condition hierarchy (see SegmentLoadingKey for detail):
+*
+*   !playbackInitiated
+*     preload==='none' (or unset)  → dormant; no trigger
+*     preload==='metadata'         → trigger on transition to 'metadata'
+*     preload==='auto'             → trigger on transition to 'auto'
+*
+*   !playbackInitiated → playbackInitiated
+*     preload !== 'auto'           → trigger (message shape changes)
+*     preload === 'auto'           → suppressed (was already full-range mode;
+*                                    let segmentStart take over post-play)
+*                                    KNOWN LIMITATION: seek-before-play with
+*                                    preload='auto' is not supported — if the
+*                                    user seeks before pressing play, the
+*                                    first re-send is delayed until the next
+*                                    segment boundary crossing post-play.
+*
+*   playbackInitiated
+*     resolvedTrackId changes      → trigger
+*     segmentStart(currentTime) changes → trigger (segment boundary only)
+*
+* @example
+* const cleanup = loadSegments({ state, owners }, { type: 'video' });
+*/
+function loadSegments({ state, owners }, config) {
+	const { type } = config;
+	const actorKey = ActorKeyByType[type];
+	const initialBandwidth = state.current.bandwidthState;
+	const throughput = createState(initialBandwidth ?? {
+		fastEstimate: 0,
+		fastTotalWeight: 0,
+		slowEstimate: 0,
+		slowTotalWeight: 0,
+		bytesSampled: 0
+	});
+	const fetchBytes = type === "video" ? createTrackedFetch(throughput, initialBandwidth !== void 0 ? (next) => {
+		state.patch({ bandwidthState: next });
+		state.flush();
+	} : void 0) : fetchStream;
+	const segmentLoader = createState(void 0);
+	const unsubActorLifecycle = owners.subscribe((o) => o[actorKey], (actor) => {
+		if (actor) segmentLoader.patch(createSegmentLoaderActor(actor, fetchBytes));
+		else if (!actor && segmentLoader.current) {
+			segmentLoader.current.destroy();
+			segmentLoader.patch(void 0);
+		}
+		return () => {
+			segmentLoader.current?.destroy();
+			segmentLoader.patch(void 0);
+		};
+	});
+	const segmentsCanLoad = createState(false);
+	const unsubscribeCanLoadSegments = combineLatest([state, segmentLoader]).subscribe(([currentState, currentSegmentLoader]) => {
+		const track = getSelectedTrack(currentState, type);
+		const trackResolved = !!track && isResolvedTrack(track);
+		const segmentLoaderActorExists = !!currentSegmentLoader;
+		segmentsCanLoad.patch(trackResolved && segmentLoaderActorExists);
+	});
+	const unsubscribeShouldLoadSegments = combineLatest([segmentsCanLoad, state]).subscribe(([segmentsCanLoad, state]) => selectLoadingInputs([segmentsCanLoad, state], type), ({ preload, playbackInitiated, currentTime, track }) => {
+		if (!(preload === "auto" || !!playbackInitiated))
+ /** @ts-expect-error */
+		segmentLoader.current?.send({
+			type: "load",
+			track
+		});
+		else segmentLoader.current?.send({
+			type: "load",
+			track,
+			range: {
+				start: currentTime,
+				end: currentTime + DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration
+			}
+		});
+	}, { equalityFn: loadingInputsEq });
+	return () => {
+		unsubscribeCanLoadSegments();
+		unsubscribeShouldLoadSegments();
+		unsubActorLifecycle();
+	};
+}
+
+//#endregion
+export { loadSegments };
+//# sourceMappingURL=load-segments.js.map

package/dist/dev/dom/features/load-segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-segments.js","names":[],"sources":["../../../../src/dom/features/load-segments.ts"],"sourcesContent":["import { combineLatest } from '../../all';\nimport { type BandwidthState, sampleBandwidth } from '../../core/abr/bandwidth-estimator';\nimport { DEFAULT_FORWARD_BUFFER_CONFIG } from '../../core/buffer/forward-buffer';\nimport { createState, type WritableState } from '../../core/state/create-state';\nimport type { AddressableObject, Presentation, ResolvedTrack } from '../../core/types';\nimport { isResolvedTrack } from '../../core/types';\nimport { getSelectedTrack, type TrackSelectionState } from '../../core/utils/track-selection';\nimport type { SourceBufferActor } from '../media/source-buffer-actor';\nimport { ChunkedStreamIterable, type ChunkedStreamIterableOptions } from '../network/chunked-stream-iterable';\nimport { fetchResolvable } from '../network/fetch';\nimport {\n  type BufferState,\n  createSegmentLoaderActor,\n  type SegmentLoaderActor,\n  type SourceBufferState,\n} from './segment-loader-actor';\nimport type { MediaTrackType } from './setup-sourcebuffer';\n\n// Re-export buffer state types for consumers that import them from this module.\nexport type { BufferState, SourceBufferState };\n\n// Map track type to SourceBufferActor owner property key.\nconst ActorKeyByType = {\n  video: 'videoBufferActor',\n  audio: 'audioBufferActor',\n} as const;\n\n// ============================================================================\n// TRACKED FETCH\n// ============================================================================\n\n/**\n * Creates a fetch function that eagerly starts the HTTP request (TTFB is\n * awaited), then returns a lazy iterable over the response body that\n * transparently samples bandwidth per chunk.\n *\n * Separating connection start from body reading ensures `fetch()` is called\n * as soon as the task begins — not deferred until the actor's append loop\n * first pulls a chunk. This makes fetch timing predictable and observable\n * (e.g. in tests that record fetched URLs) regardless of downstream consumers.\n *\n * `onSample` bridges throughput state outward; see Phase 2 comment for detail.\n */\ntype FetchOptions = RequestInit & ChunkedStreamIterableOptions;\n\nfunction createTrackedFetch(\n  throughput: WritableState<BandwidthState>,\n  onSample?: (next: BandwidthState) => void\n): (addressable: AddressableObject, options?: FetchOptions) => Promise<AsyncIterable<Uint8Array>> {\n  return async (addressable, options) => {\n    const { minChunkSize, ...fetchOptions } = options ?? {};\n    const response = await fetchResolvable(addressable, fetchOptions);\n    if (!response.body) throw new Error('Response has no body');\n    const body = response.body;\n    return {\n      [Symbol.asyncIterator]: async function* () {\n        let chunkStart = performance.now();\n        for await (const chunk of new ChunkedStreamIterable(\n          body,\n          ...(minChunkSize !== undefined ? [{ minChunkSize }] : [])\n        )) {\n          const elapsed = performance.now() - chunkStart;\n          const next = sampleBandwidth(throughput.current, elapsed, chunk.byteLength);\n          throughput.patch(next);\n          throughput.flush();\n          onSample?.(next);\n          yield chunk;\n          chunkStart = performance.now();\n        }\n      },\n    };\n  };\n}\n\n/**\n * Non-tracking fetch: eagerly starts the request and returns the response body\n * as a lazy chunk iterable. Used for audio tracks which don't sample bandwidth.\n * Pass `minChunkSize: Infinity` to accumulate the full body as a single chunk\n * (equivalent to arrayBuffer() but through the same streaming path).\n */\nasync function fetchStream(addressable: AddressableObject, options?: FetchOptions): Promise<AsyncIterable<Uint8Array>> {\n  const { minChunkSize, ...fetchOptions } = options ?? {};\n  const response = await fetchResolvable(addressable, fetchOptions);\n  if (!response.body) throw new Error('Response has no body');\n  return new ChunkedStreamIterable(response.body, ...(minChunkSize !== undefined ? [{ minChunkSize }] : []));\n}\n\n// ============================================================================\n// STATE & OWNERS\n// ============================================================================\n\n/**\n * State shape for segment loading.\n */\nexport interface SegmentLoadingState extends TrackSelectionState {\n  presentation?: Presentation;\n  preload?: string;\n  bandwidthState?: BandwidthState;\n  /** Current playback position in seconds. Defaults to 0 when undefined. */\n  currentTime?: number;\n  /** True once the user has initiated playback. Allows segment loading regardless of preload setting. */\n  playbackInitiated?: boolean;\n}\n\n/**\n * Owners shape for segment loading.\n */\nexport interface SegmentLoadingOwners {\n  videoBuffer?: SourceBuffer;\n  audioBuffer?: SourceBuffer;\n  videoBufferActor?: SourceBufferActor;\n  audioBufferActor?: SourceBufferActor;\n}\n\n// ============================================================================\n// STATE SELECTOR\n// ============================================================================\n\n/**\n * The subset of state that drives segment loading decisions.\n * A plain \"pick\" with one derived field (resolved track ID).\n */\ntype LoadingInputs = {\n  playbackInitiated: boolean | undefined;\n  preload: string | undefined;\n  currentTime: number | undefined;\n  /** @TODO cleanup type precision via inference+generics */\n  track: ReturnType<typeof getSelectedTrack>;\n  segmentsCanLoad: boolean;\n};\n\nfunction selectLoadingInputs(\n  [segmentsCanLoad, state]: [boolean, SegmentLoadingState],\n  type: MediaTrackType\n): LoadingInputs {\n  const { playbackInitiated, preload, currentTime } = state;\n  const track = getSelectedTrack(state, type);\n  return {\n    playbackInitiated,\n    preload,\n    currentTime,\n    track,\n    segmentsCanLoad,\n  };\n}\n\n/**\n * Equality function encoding the condition hierarchy for relevant changes.\n *\n * Pre-play (!playbackInitiated):\n *   Only preload changes matter. currentTime and resolvedTrackId are ignored\n *   (track changes not supported pre-play; currentTime value is used at\n *   trigger time but changes don't re-trigger).\n *\n * playbackInitiated transition:\n *   Always fires (handled in the subscriber; preload='auto' suppression\n *   applied there since equality functions have no memory of prior values).\n *\n * Post-play (playbackInitiated):\n *   resolvedTrackId changes (track switch or previously-unresolved track\n *   resolving) and currentTime changes both trigger. preload is irrelevant.\n */\nconst segmentStartFor = (currentTime: number | undefined, track: ResolvedTrack | undefined) => {\n  if (currentTime == null) return undefined;\n  return track?.segments.find(\n    ({ startTime, duration }, i, segments) =>\n      currentTime >= startTime && (currentTime < startTime + duration || i === segments.length - 1)\n  )?.startTime;\n};\n\n/**\n * Returns true when the inputs are equal (no meaningful change — don't fire).\n * Returns false when the inputs differ in a way that requires a new message.\n *\n * This IS the shouldLoadSegments logic, expressed as an equality function.\n */\nfunction loadingInputsEq(prevState: LoadingInputs, curState: LoadingInputs): boolean {\n  if (!curState.segmentsCanLoad) return true;\n  // Haven't started playback. Only care about preload changes.\n  if (!curState.playbackInitiated) {\n    if (curState.preload === 'none') return true; // blocked — equal, don't fire\n    return curState.preload === prevState.preload; // equal if preload unchanged\n  }\n  // Transition: !playbackInitiated → playbackInitiated\n  if (!prevState.playbackInitiated && curState.playbackInitiated) {\n    if (prevState.preload !== 'auto') return false; // fire — message shape changes\n    // preload was 'auto': fall through to segment comparison (suppress if same position)\n  }\n\n  // Don't treat as a change if we don't (yet) have a currently resolved track.\n  if (!curState.track || !isResolvedTrack(curState.track)) return true;\n\n  // If we *do* have a currently resolved track, treat as a change if the track ids have changed\n  if (prevState.track?.id !== curState.track.id && isResolvedTrack(curState.track)) return false;\n\n  // Finally, if playback has initiated *and* we have a resolved track, check if currentTime\n  // has changed \"significantly\" (based on segment time range boundaries) and treat as a change\n  // if so (regardless of whether or not the track has changed)\n  return (\n    segmentStartFor(prevState.currentTime, curState.track as ResolvedTrack) ===\n    segmentStartFor(curState.currentTime, curState.track as ResolvedTrack)\n  );\n}\n\n// ============================================================================\n// REACTOR\n// ============================================================================\n\n/**\n * Load segments orchestration — Reactor layer.\n *\n * Sends typed load messages to a SegmentLoaderActor when relevant conditions\n * change. Uses targeted subscriptions rather than broad combineLatest so only\n * meaningful state changes trigger evaluation.\n *\n * Condition hierarchy (see SegmentLoadingKey for detail):\n *\n *   !playbackInitiated\n *     preload==='none' (or unset)  → dormant; no trigger\n *     preload==='metadata'         → trigger on transition to 'metadata'\n *     preload==='auto'             → trigger on transition to 'auto'\n *\n *   !playbackInitiated → playbackInitiated\n *     preload !== 'auto'           → trigger (message shape changes)\n *     preload === 'auto'           → suppressed (was already full-range mode;\n *                                    let segmentStart take over post-play)\n *                                    KNOWN LIMITATION: seek-before-play with\n *                                    preload='auto' is not supported — if the\n *                                    user seeks before pressing play, the\n *                                    first re-send is delayed until the next\n *                                    segment boundary crossing post-play.\n *\n *   playbackInitiated\n *     resolvedTrackId changes      → trigger\n *     segmentStart(currentTime) changes → trigger (segment boundary only)\n *\n * @example\n * const cleanup = loadSegments({ state, owners }, { type: 'video' });\n */\nexport function loadSegments(\n  {\n    state,\n    owners,\n  }: {\n    state: WritableState<SegmentLoadingState>;\n    owners: WritableState<SegmentLoadingOwners>;\n  },\n  config: { type: MediaTrackType }\n): () => void {\n  const { type } = config;\n  const actorKey = ActorKeyByType[type];\n\n  // Local throughput state — owns BandwidthState for this track's fetch loop.\n  // Sampling is handled transparently inside fetchBytes; callers never touch it.\n  //\n  // MIGRATION BRIDGE: the onSample callback below keeps global state.bandwidthState\n  // in sync so ABR (selectVideoTrack) continues to work unchanged. Remove this\n  // bridge once ABR reads from throughput directly.\n  const initialBandwidth = state.current.bandwidthState;\n  const throughput = createState<BandwidthState>(\n    initialBandwidth ?? {\n      fastEstimate: 0,\n      fastTotalWeight: 0,\n      slowEstimate: 0,\n      slowTotalWeight: 0,\n      bytesSampled: 0,\n    }\n  );\n\n  const fetchBytes =\n    type === 'video'\n      ? createTrackedFetch(\n          throughput,\n          initialBandwidth !== undefined\n            ? (next) => {\n                state.patch({ bandwidthState: next });\n                // Flush immediately so switchQuality sees the new estimate before the\n                // next segment fetch starts, rather than waiting for the microtask queue.\n                state.flush();\n              }\n            : undefined\n        )\n      : fetchStream;\n\n  const segmentLoader = createState<SegmentLoaderActor | undefined>(undefined);\n\n  // SegmentLoaderActor lifecycle — watch only the actor key in owners so this\n  // subscription does not fire on unrelated owners changes.\n  const unsubActorLifecycle = owners.subscribe(\n    (o) => o[actorKey],\n    (actor) => {\n      if (actor) {\n        segmentLoader.patch(createSegmentLoaderActor(actor, fetchBytes));\n      } else if (!actor && segmentLoader.current) {\n        segmentLoader.current.destroy();\n        segmentLoader.patch(undefined);\n      }\n      return () => {\n        segmentLoader.current?.destroy();\n        segmentLoader.patch(undefined);\n      };\n    }\n  );\n\n  const segmentsCanLoad = createState<boolean>(false);\n  const unsubscribeCanLoadSegments = combineLatest([state, segmentLoader]).subscribe(\n    ([currentState, currentSegmentLoader]) => {\n      const track = getSelectedTrack(currentState, type);\n      const trackResolved = !!track && isResolvedTrack(track);\n      const segmentLoaderActorExists = !!currentSegmentLoader;\n      segmentsCanLoad.patch(trackResolved && segmentLoaderActorExists);\n    }\n  );\n\n  const unsubscribeShouldLoadSegments = combineLatest([segmentsCanLoad, state]).subscribe(\n    ([segmentsCanLoad, state]) => selectLoadingInputs([segmentsCanLoad, state], type),\n    ({ preload, playbackInitiated, currentTime, track }) => {\n      const fullMode = preload === 'auto' || !!playbackInitiated;\n\n      if (!fullMode) {\n        // Metadata mode: init only, no range.\n        /** @ts-expect-error */\n        segmentLoader.current?.send({ type: 'load', track });\n      } else {\n        segmentLoader.current?.send({\n          type: 'load',\n          /** @ts-expect-error */\n          track,\n          range: {\n            start: currentTime as number,\n            end: (currentTime as number) + DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration,\n          },\n        });\n      }\n    },\n    { equalityFn: loadingInputsEq }\n  );\n\n  return () => {\n    unsubscribeCanLoadSegments();\n    unsubscribeShouldLoadSegments();\n    unsubActorLifecycle();\n  };\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,61 @@
+import { WritableState } from "../../core/state/create-state.js";
+import { Presentation } from "../../core/types/index.js";
+
+//#region src/dom/features/load-text-track-cues.d.ts
+/**
+ * Loaded-segment record for a single text track.
+ */
+interface TextTrackSegmentState {
+  segments: Array<{
+    id: string;
+  }>;
+}
+/**
+ * Buffer model for text track cues — keyed by track ID.
+ *
+ * Using a per-track-ID map (rather than fixed 'video'/'audio' keys) because
+ * there can be N text tracks — one per language/subtitle variant.
+ */
+type TextTrackBufferState = Record<string, TextTrackSegmentState>;
+/**
+ * State shape for text track cue loading.
+ */
+interface TextTrackCueLoadingState {
+  selectedTextTrackId?: string;
+  presentation?: Presentation;
+  /** Current playback position — used to gate VTT segment fetching to the forward buffer window. */
+  currentTime?: number;
+  /** Loaded-segment model for text tracks, keyed by track ID. */
+  textBufferState?: TextTrackBufferState;
+}
+/**
+ * Owners shape for text track cue loading.
+ */
+interface TextTrackCueLoadingOwners {
+  textTracks?: Map<string, HTMLTrackElement>;
+}
+/**
+ * Load text track cues orchestration.
+ *
+ * Triggers when:
+ * - Text track is selected
+ * - Track is resolved (has segments)
+ * - Track element exists
+ *
+ * Fetches and parses VTT segments within the forward buffer window, then adds
+ * cues to the track incrementally. Continues on segment errors to provide
+ * partial subtitles.
+ *
+ * @example
+ * const cleanup = loadTextTrackCues({ state, owners });
+ */
+declare function loadTextTrackCues({
+  state,
+  owners
+}: {
+  state: WritableState<TextTrackCueLoadingState>;
+  owners: WritableState<TextTrackCueLoadingOwners>;
+}): () => void;
+//#endregion
+export { TextTrackBufferState, loadTextTrackCues };
+//# sourceMappingURL=load-text-track-cues.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load-text-track-cues.d.ts","names":[],"sources":["../../../../src/dom/features/load-text-track-cues.ts"],"mappings":";;;;;;AA8GA;UAAiB,qBAAA;EACf,QAAA,EAAU,KAAA;IAAQ,EAAA;EAAA;AAAA;;;;AASpB;;;KAAY,oBAAA,GAAuB,MAAA,SAAe,qBAAA;;AAKlD;;UAAiB,wBAAA;EACf,mBAAA;EACA,YAAA,GAAe,YAAA;EAAf;EAEA,WAAA;EAAA;EAEA,eAAA,GAAkB,oBAAA;AAAA;;;AAMpB;UAAiB,yBAAA;EACf,UAAA,GAAa,GAAA,SAAY,gBAAA;AAAA;;;;;;;;;;;;;;;;iBAoGX,iBAAA,CAAA;EACd,KAAA;EACA;AAAA;EAEA,KAAA,EAAO,aAAA,CAAc,wBAAA;EACrB,MAAA,EAAQ,aAAA,CAAc,yBAAA;AAAA"}

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

@@ -0,0 +1,151 @@
+import { getSegmentsToLoad } from "../../core/buffer/forward-buffer.js";
+import { isResolvedTrack } from "../../core/types/index.js";
+import { combineLatest } from "../../core/reactive/combine-latest.js";
+import { parseVttSegment } from "../text/parse-vtt-segment.js";
+
+//#region src/dom/features/load-text-track-cues.ts
+function isDuplicateCue(cue, textTrack) {
+	const { cues } = textTrack;
+	if (!cues) return false;
+	for (let i = 0; i < cues.length; i++) {
+		const existing = cues[i];
+		if (existing.startTime === cue.startTime && existing.endTime === cue.endTime && existing.text === cue.text) return true;
+	}
+	return false;
+}
+const loadVttSegmentTask = async ({ segment }, context) => {
+	const cues = await parseVttSegment(segment.url);
+	for (const cue of cues) if (!isDuplicateCue(cue, context.textTrack)) context.textTrack.addCue(cue);
+};
+/**
+* Load text track cues task (composite - orchestrates VTT segment subtasks).
+*/
+const loadTextTrackCuesTask = async ({ currentState }, context) => {
+	const track = findSelectedTextTrack(currentState);
+	if (!track || !isResolvedTrack(track)) return;
+	const { segments } = track;
+	if (segments.length === 0) return;
+	const trackId = track.id;
+	const loadedIds = new Set((currentState.textBufferState?.[trackId]?.segments ?? []).map((s) => s.id));
+	const segmentsToLoad = getSegmentsToLoad(segments, segments.filter((s) => loadedIds.has(s.id)), currentState.currentTime ?? 0).filter((s) => !loadedIds.has(s.id));
+	if (segmentsToLoad.length === 0) return;
+	for (const segment of segmentsToLoad) {
+		if (context.signal.aborted) break;
+		try {
+			await loadVttSegmentTask({ segment }, { textTrack: context.textTrack });
+			const latest = context.state.current.textBufferState ?? {};
+			const trackState = latest[trackId] ?? { segments: [] };
+			context.state.patch({ textBufferState: {
+				...latest,
+				[trackId]: { segments: [...trackState.segments, { id: segment.id }] }
+			} });
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") break;
+			console.error("Failed to load VTT segment:", error);
+		}
+	}
+	if (context.textTrack.mode === "showing" && context.textTrack.cues) Array.from(context.textTrack.cues).forEach((cue) => {
+		context.textTrack.addCue(cue);
+	});
+	await new Promise((resolve) => requestAnimationFrame(resolve));
+};
+/**
+* Find the selected text track in the presentation.
+*/
+function findSelectedTextTrack(state) {
+	if (!state.presentation || !state.selectedTextTrackId) return;
+	const textSet = state.presentation.selectionSets.find((set) => set.type === "text");
+	if (!textSet?.switchingSets?.[0]?.tracks) return;
+	return textSet.switchingSets[0].tracks.find((t) => t.id === state.selectedTextTrackId);
+}
+/**
+* Get the browser's TextTrack object for the selected text track.
+*
+* Retrieves the live TextTrack interface from the track element in owners,
+* which is used for adding cues, checking mode, and managing track state.
+*
+* Note: Returns the DOM TextTrack interface (HTMLTrackElement.track),
+* not the presentation Track metadata type.
+*
+* @param state - Current playback state (track selection)
+* @param owners - DOM owners containing track elements map
+* @returns DOM TextTrack interface or undefined if not found
+*/
+function getSelectedTextTrackFromOwners(state, owners) {
+	const trackId = state.selectedTextTrackId;
+	if (!trackId || !owners.textTracks) return;
+	return owners.textTracks.get(trackId)?.track;
+}
+/**
+* Check if we can load text track cues.
+*
+* Requires:
+* - Selected text track ID exists
+* - Track elements map exists
+* - Track element exists for selected track
+*/
+function canLoadTextTrackCues(state, owners) {
+	return !!state.selectedTextTrackId && !!owners.textTracks && owners.textTracks.has(state.selectedTextTrackId);
+}
+/**
+* Check if we should load text track cues.
+*
+* Only load if:
+* - Track is resolved (has segments)
+* - Track has at least one segment
+* - Track element exists
+*/
+function shouldLoadTextTrackCues(state, owners) {
+	if (!canLoadTextTrackCues(state, owners)) return false;
+	const track = findSelectedTextTrack(state);
+	if (!track || !isResolvedTrack(track) || track.segments.length === 0) return false;
+	if (!getSelectedTextTrackFromOwners(state, owners)) return false;
+	return true;
+}
+/**
+* Load text track cues orchestration.
+*
+* Triggers when:
+* - Text track is selected
+* - Track is resolved (has segments)
+* - Track element exists
+*
+* Fetches and parses VTT segments within the forward buffer window, then adds
+* cues to the track incrementally. Continues on segment errors to provide
+* partial subtitles.
+*
+* @example
+* const cleanup = loadTextTrackCues({ state, owners });
+*/
+function loadTextTrackCues({ state, owners }) {
+	let currentTask = null;
+	let abortController = null;
+	let lastTrackId;
+	const cleanup = combineLatest([state, owners]).subscribe(async ([currentState, currentOwners]) => {
+		if (currentState.selectedTextTrackId !== lastTrackId) {
+			lastTrackId = currentState.selectedTextTrackId;
+			abortController?.abort();
+			currentTask = null;
+		}
+		if (currentTask) return;
+		if (!shouldLoadTextTrackCues(currentState, currentOwners)) return;
+		const textTrack = getSelectedTextTrackFromOwners(currentState, currentOwners);
+		if (!textTrack) return;
+		abortController = new AbortController();
+		currentTask = loadTextTrackCuesTask({ currentState }, {
+			signal: abortController.signal,
+			textTrack,
+			state
+		}).finally(() => {
+			currentTask = null;
+		});
+	});
+	return () => {
+		abortController?.abort();
+		cleanup();
+	};
+}
+
+//#endregion
+export { loadTextTrackCues };
+//# sourceMappingURL=load-text-track-cues.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load-text-track-cues.js","names":[],"sources":["../../../../src/dom/features/load-text-track-cues.ts"],"sourcesContent":["import { getSegmentsToLoad } from '../../core/buffer/forward-buffer';\nimport { combineLatest } from '../../core/reactive/combine-latest';\nimport type { WritableState } from '../../core/state/create-state';\nimport type { Presentation, Segment, TextTrack } from '../../core/types';\nimport { isResolvedTrack } from '../../core/types';\nimport { parseVttSegment } from '../text/parse-vtt-segment';\n\nfunction isDuplicateCue(cue: VTTCue, textTrack: globalThis.TextTrack): boolean {\n  const { cues } = textTrack;\n  if (!cues) return false;\n  for (let i = 0; i < cues.length; i++) {\n    const existing = cues[i] as VTTCue;\n    if (existing.startTime === cue.startTime && existing.endTime === cue.endTime && existing.text === cue.text) {\n      return true;\n    }\n  }\n  return false;\n}\n\nconst loadVttSegmentTask = async (\n  { segment }: { segment: Segment },\n  context: { textTrack: globalThis.TextTrack }\n): Promise<void> => {\n  const cues = await parseVttSegment(segment.url);\n  for (const cue of cues) {\n    if (!isDuplicateCue(cue, context.textTrack)) {\n      context.textTrack.addCue(cue);\n    }\n  }\n};\n\n// ============================================================================\n// MAIN TASK (composite - orchestrates subtasks)\n// ============================================================================\n\n/**\n * Load text track cues task (composite - orchestrates VTT segment subtasks).\n */\nconst loadTextTrackCuesTask = async (\n  { currentState }: { currentState: TextTrackCueLoadingState },\n  context: {\n    signal: AbortSignal;\n    textTrack: globalThis.TextTrack;\n    state: WritableState<TextTrackCueLoadingState>;\n  }\n): Promise<void> => {\n  const track = findSelectedTextTrack(currentState);\n  if (!track || !isResolvedTrack(track)) return;\n\n  const { segments } = track;\n  if (segments.length === 0) return;\n\n  const trackId = track.id;\n\n  // Resolve segments already recorded in the state model for this track.\n  // Keyed by track ID so multiple text tracks don't interfere with each other.\n  const loadedIds = new Set((currentState.textBufferState?.[trackId]?.segments ?? []).map((s) => s.id));\n  const alreadyLoaded = segments.filter((s) => loadedIds.has(s.id));\n\n  // Apply the same forward buffer window as audio/video segment loading.\n  const currentTime = currentState.currentTime ?? 0;\n  const segmentsToLoad = getSegmentsToLoad(segments, alreadyLoaded, currentTime).filter((s) => !loadedIds.has(s.id));\n\n  if (segmentsToLoad.length === 0) return;\n\n  // Execute subtasks sequentially, recording each loaded segment in state.\n  for (const segment of segmentsToLoad) {\n    if (context.signal.aborted) break;\n\n    try {\n      await loadVttSegmentTask({ segment }, { textTrack: context.textTrack });\n\n      // Record the loaded segment in shared state — mirrors bufferState for\n      // audio/video and supports N text tracks keyed by track ID.\n      const latest = context.state.current.textBufferState ?? {};\n      const trackState = latest[trackId] ?? { segments: [] };\n      context.state.patch({\n        textBufferState: {\n          ...latest,\n          [trackId]: { segments: [...trackState.segments, { id: segment.id }] },\n        },\n      });\n    } catch (error) {\n      if (error instanceof Error && error.name === 'AbortError') break;\n      console.error('Failed to load VTT segment:', error);\n      // Continue to next segment (graceful degradation)\n    }\n  }\n\n  // Chrome bug: after a track goes through mode='disabled' (which clears cues) and back\n  // to 'showing', cues added to the track aren't activated. Re-adding all cues forces\n  // Chrome to re-process them. Safe no-op in other browsers.\n  // Mirrors the workaround in HlsMediaTextTracksMixin (packages/core/src/dom/media/hls/text-tracks.ts).\n  if (context.textTrack.mode === 'showing' && context.textTrack.cues) {\n    Array.from(context.textTrack.cues).forEach((cue) => {\n      context.textTrack.addCue(cue);\n    });\n  }\n\n  // Wait a frame before completing to allow state updates to flush\n  await new Promise((resolve) => requestAnimationFrame(resolve));\n};\n\n// ============================================================================\n// STATE & OWNERS\n// ============================================================================\n\n/**\n * Loaded-segment record for a single text track.\n */\nexport interface TextTrackSegmentState {\n  segments: Array<{ id: string }>;\n}\n\n/**\n * Buffer model for text track cues — keyed by track ID.\n *\n * Using a per-track-ID map (rather than fixed 'video'/'audio' keys) because\n * there can be N text tracks — one per language/subtitle variant.\n */\nexport type TextTrackBufferState = Record<string, TextTrackSegmentState>;\n\n/**\n * State shape for text track cue loading.\n */\nexport interface TextTrackCueLoadingState {\n  selectedTextTrackId?: string;\n  presentation?: Presentation;\n  /** Current playback position — used to gate VTT segment fetching to the forward buffer window. */\n  currentTime?: number;\n  /** Loaded-segment model for text tracks, keyed by track ID. */\n  textBufferState?: TextTrackBufferState;\n}\n\n/**\n * Owners shape for text track cue loading.\n */\nexport interface TextTrackCueLoadingOwners {\n  textTracks?: Map<string, HTMLTrackElement>;\n}\n\n/**\n * Find the selected text track in the presentation.\n */\nfunction findSelectedTextTrack(state: TextTrackCueLoadingState): TextTrack | undefined {\n  if (!state.presentation || !state.selectedTextTrackId) {\n    return undefined;\n  }\n\n  const textSet = state.presentation.selectionSets.find((set) => set.type === 'text');\n  if (!textSet?.switchingSets?.[0]?.tracks) {\n    return undefined;\n  }\n\n  const track = textSet.switchingSets[0].tracks.find((t) => t.id === state.selectedTextTrackId);\n\n  return track as TextTrack | undefined;\n}\n\n/**\n * Get the browser's TextTrack object for the selected text track.\n *\n * Retrieves the live TextTrack interface from the track element in owners,\n * which is used for adding cues, checking mode, and managing track state.\n *\n * Note: Returns the DOM TextTrack interface (HTMLTrackElement.track),\n * not the presentation Track metadata type.\n *\n * @param state - Current playback state (track selection)\n * @param owners - DOM owners containing track elements map\n * @returns DOM TextTrack interface or undefined if not found\n */\nfunction getSelectedTextTrackFromOwners(\n  state: TextTrackCueLoadingState,\n  owners: TextTrackCueLoadingOwners\n): globalThis.TextTrack | undefined {\n  const trackId = state.selectedTextTrackId;\n  if (!trackId || !owners.textTracks) {\n    return undefined;\n  }\n\n  const trackElement = owners.textTracks.get(trackId);\n  return trackElement?.track;\n}\n\n/**\n * Check if we can load text track cues.\n *\n * Requires:\n * - Selected text track ID exists\n * - Track elements map exists\n * - Track element exists for selected track\n */\nexport function canLoadTextTrackCues(state: TextTrackCueLoadingState, owners: TextTrackCueLoadingOwners): boolean {\n  return !!state.selectedTextTrackId && !!owners.textTracks && owners.textTracks.has(state.selectedTextTrackId);\n}\n\n/**\n * Check if we should load text track cues.\n *\n * Only load if:\n * - Track is resolved (has segments)\n * - Track has at least one segment\n * - Track element exists\n */\nexport function shouldLoadTextTrackCues(state: TextTrackCueLoadingState, owners: TextTrackCueLoadingOwners): boolean {\n  if (!canLoadTextTrackCues(state, owners)) {\n    return false;\n  }\n\n  const track = findSelectedTextTrack(state);\n  if (!track || !isResolvedTrack(track) || track.segments.length === 0) {\n    return false;\n  }\n\n  const textTrack = getSelectedTextTrackFromOwners(state, owners);\n  if (!textTrack) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Load text track cues orchestration.\n *\n * Triggers when:\n * - Text track is selected\n * - Track is resolved (has segments)\n * - Track element exists\n *\n * Fetches and parses VTT segments within the forward buffer window, then adds\n * cues to the track incrementally. Continues on segment errors to provide\n * partial subtitles.\n *\n * @example\n * const cleanup = loadTextTrackCues({ state, owners });\n */\nexport function loadTextTrackCues({\n  state,\n  owners,\n}: {\n  state: WritableState<TextTrackCueLoadingState>;\n  owners: WritableState<TextTrackCueLoadingOwners>;\n}): () => void {\n  let currentTask: Promise<void> | null = null;\n  let abortController: AbortController | null = null;\n  let lastTrackId: string | undefined;\n\n  const cleanup = combineLatest([state, owners]).subscribe(\n    async ([currentState, currentOwners]: [TextTrackCueLoadingState, TextTrackCueLoadingOwners]) => {\n      // Abort any in-progress task when the selected track changes.\n      // The new track's textBufferState entry will be empty, so the task\n      // naturally starts fresh without needing any explicit reset.\n      if (currentState.selectedTextTrackId !== lastTrackId) {\n        lastTrackId = currentState.selectedTextTrackId;\n        abortController?.abort();\n        currentTask = null;\n      }\n\n      if (currentTask) return; // Task already in progress\n      if (!shouldLoadTextTrackCues(currentState, currentOwners)) return;\n\n      const textTrack = getSelectedTextTrackFromOwners(currentState, currentOwners);\n      if (!textTrack) return;\n\n      // Create abort controller and invoke task\n      abortController = new AbortController();\n      currentTask = loadTextTrackCuesTask(\n        { currentState },\n        { signal: abortController.signal, textTrack, state }\n      ).finally(() => {\n        currentTask = null;\n      });\n    }\n  );\n\n  return () => {\n    abortController?.abort();\n    cleanup();\n  };\n}\n"],"mappings":"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"}