@videojs/spf 10.0.0-beta.8 → 10.0.0-rc.1

package/dist/adapter-ClnRGbQf.js

@@ -1,3539 +0,0 @@
-import { listen } from "@videojs/utils/dom";
-import { isNil } from "@videojs/utils/predicate";
-
-//#region src/core/state/create-state.ts
-/**
-* Reactive state container with selectors, custom equality, and batched updates.
-*
-* Manages both immutable state values and mutable object references (e.g., HTMLMediaElement).
-*/
-const STATE_SYMBOL = Symbol("@videojs/spf/state");
-/**
-* Default equality function using Object.is.
-*/
-function defaultEquality(a, b) {
-	return Object.is(a, b);
-}
-/**
-* State container implementation.
-*/
-var StateContainer = class {
-	[STATE_SYMBOL] = true;
-	#current;
-	#pending = null;
-	#pendingFlush = false;
-	#equalityFn;
-	#listeners = /* @__PURE__ */ new Set();
-	#selectorListeners = /* @__PURE__ */ new Set();
-	constructor(initial, config) {
-		this.#current = typeof initial === "object" && initial !== null ? { ...initial } : initial;
-		this.#equalityFn = config?.equalityFn ?? defaultEquality;
-	}
-	get current() {
-		return this.#pending ?? this.#current;
-	}
-	patch(partial) {
-		const base = this.#pending ?? this.#current;
-		if (typeof base !== "object" || base === null) {
-			const value = partial;
-			if (!Object.is(base, value)) {
-				this.#pending = value;
-				this.#scheduleFlush();
-			}
-			return;
-		}
-		const next = { ...base };
-		let changed = false;
-		for (const key in partial) {
-			if (!Object.hasOwn(partial, key)) continue;
-			const value = partial[key];
-			if (!Object.is(base[key], value)) {
-				next[key] = value;
-				changed = true;
-			}
-		}
-		if (changed) {
-			this.#pending = next;
-			this.#scheduleFlush();
-		}
-	}
-	subscribe(selectorOrListener, maybeListener, options) {
-		if (maybeListener === void 0) {
-			const listener$1 = selectorOrListener;
-			this.#listeners.add(listener$1);
-			listener$1(this.current);
-			return () => {
-				this.#listeners.delete(listener$1);
-			};
-		}
-		const selector = selectorOrListener;
-		const listener = maybeListener;
-		const entry = {
-			selector,
-			listener,
-			options: options ?? {}
-		};
-		this.#selectorListeners.add(entry);
-		listener(selector(this.current));
-		return () => {
-			this.#selectorListeners.delete(entry);
-		};
-	}
-	flush() {
-		if (this.#pending === null) return;
-		const prev = this.#current;
-		const next = this.#pending;
-		this.#pending = null;
-		this.#pendingFlush = false;
-		if (this.#equalityFn(prev, next)) return;
-		this.#current = next;
-		for (const listener of this.#listeners) listener(this.#current);
-		for (const entry of this.#selectorListeners) {
-			const prevSelected = entry.selector(prev);
-			const nextSelected = entry.selector(this.#current);
-			if (!(entry.options.equalityFn ?? Object.is)(prevSelected, nextSelected)) entry.listener(nextSelected);
-		}
-	}
-	#scheduleFlush() {
-		if (this.#pendingFlush) return;
-		this.#pendingFlush = true;
-		queueMicrotask(() => this.flush());
-	}
-};
-/**
-* Create a reactive state container.
-*
-* @example
-* ```typescript
-* const state = createState({ count: 0 });
-*
-* // Subscribe to changes
-* state.subscribe((current, prev) => {
-*   console.log('Changed:', prev, '->', current);
-* });
-*
-* // Updates are batched
-* state.patch({ count: 1 });
-* state.patch({ count: 2 });
-* // Only one notification fires (with count: 2)
-* ```
-*
-* @example Selector subscriptions
-* ```typescript
-* const state = createState({ count: 0, name: 'test' });
-*
-* // Only notified when count changes
-* state.subscribe(
-*   s => s.count,
-*   (current, prev) => console.log(current, prev)
-* );
-* ```
-*
-* @example Custom equality
-* ```typescript
-* const state = createState(
-*   { count: 0, name: 'test' },
-*   { equalityFn: (a, b) => a.count === b.count }
-* );
-* ```
-*/
-function createState(initial, config) {
-	return new StateContainer(initial, config);
-}
-
-//#endregion
-//#region src/core/hls/parse-attributes.ts
-/**
-* Parse HLS attribute list from a tag line.
-* Handles both quoted and unquoted values.
-*/
-function parseAttributeList(line) {
-	const attributes = /* @__PURE__ */ new Map();
-	for (const match of line.matchAll(/([A-Z0-9-]+)=(?:"([^"]*)"|([^,]*))/g)) {
-		const key = match[1];
-		const value = match[2] ?? match[3] ?? "";
-		if (key) attributes.set(key, value);
-	}
-	return attributes;
-}
-/**
-* Parse RESOLUTION attribute value (WIDTHxHEIGHT).
-*/
-function parseResolution(value) {
-	const match = /^(\d+)x(\d+)$/.exec(value);
-	if (!match) return null;
-	return {
-		width: Number.parseInt(match[1], 10),
-		height: Number.parseInt(match[2], 10)
-	};
-}
-/**
-* Parse FRAME-RATE attribute to rational frame rate.
-*/
-function parseFrameRate(value) {
-	const fps = Number.parseFloat(value);
-	if (Number.isNaN(fps) || fps <= 0) return void 0;
-	if (Math.abs(fps - 23.976) < .01) return {
-		frameRateNumerator: 24e3,
-		frameRateDenominator: 1001
-	};
-	if (Math.abs(fps - 29.97) < .01) return {
-		frameRateNumerator: 3e4,
-		frameRateDenominator: 1001
-	};
-	if (Math.abs(fps - 59.94) < .01) return {
-		frameRateNumerator: 6e4,
-		frameRateDenominator: 1001
-	};
-	if (fps % 1 === 0) return { frameRateNumerator: Math.round(fps) };
-	return { frameRateNumerator: Math.round(fps) };
-}
-/**
-* Parse CODECS attribute into separate video and audio codecs.
-*/
-function parseCodecs(codecs) {
-	const parts = codecs.split(",").map((s) => s.trim());
-	const result = {};
-	for (const codec of parts) if (codec.startsWith("avc1.") || codec.startsWith("hvc1.") || codec.startsWith("hev1.")) result.video = codec;
-	else if (codec.startsWith("mp4a.")) result.audio = codec;
-	return result;
-}
-/**
-* Parse #EXTINF duration value.
-*/
-function parseExtInfDuration(value) {
-	const durationPart = value.split(",")[0] ?? value;
-	const duration = Number.parseFloat(durationPart);
-	return Number.isNaN(duration) ? 0 : duration;
-}
-/**
-* Parse BYTERANGE attribute value.
-* Format: "length[@offset]"
-* If offset is omitted, it continues from the previous byte range end.
-*/
-function parseByteRange(value, previousEnd) {
-	const match = /^(\d+)(?:@(\d+))?$/.exec(value);
-	if (!match) return null;
-	const length = Number.parseInt(match[1], 10);
-	if (Number.isNaN(length)) return null;
-	let start;
-	if (match[2] !== void 0) {
-		start = Number.parseInt(match[2], 10);
-		if (Number.isNaN(start)) return null;
-	} else if (previousEnd !== void 0) start = previousEnd;
-	else return null;
-	return {
-		start,
-		end: start + length - 1
-	};
-}
-/**
-* Create AttributeList from raw attribute string.
-*/
-function createAttributeList(line) {
-	const map = parseAttributeList(line);
-	return {
-		get(key) {
-			return map.get(key);
-		},
-		getInt(key, defaultValue) {
-			const value = map.get(key);
-			if (value === void 0) return defaultValue;
-			const parsed = Number.parseInt(value, 10);
-			return Number.isNaN(parsed) ? defaultValue : parsed;
-		},
-		getFloat(key, defaultValue) {
-			const value = map.get(key);
-			if (value === void 0) return defaultValue;
-			const parsed = Number.parseFloat(value);
-			return Number.isNaN(parsed) ? defaultValue : parsed;
-		},
-		getBool(key) {
-			return map.get(key) === "YES";
-		},
-		getResolution(key) {
-			const value = map.get(key);
-			if (!value) return void 0;
-			return parseResolution(value) ?? void 0;
-		},
-		getFrameRate(key) {
-			const value = map.get(key);
-			if (!value) return void 0;
-			return parseFrameRate(value);
-		}
-	};
-}
-/**
-* Match a tag and extract its attributes.
-* Returns null if the line doesn't match the tag.
-*/
-function matchTag(line, tag) {
-	const prefix = `#${tag}:`;
-	if (!line.startsWith(prefix)) return null;
-	return createAttributeList(line.slice(prefix.length));
-}
-
-//#endregion
-//#region src/core/hls/resolve-url.ts
-/**
-* Resolve a potentially relative URL against a base URL using native URL API.
-*/
-function resolveUrl(url, baseUrl) {
-	return new URL(url, baseUrl).href;
-}
-
-//#endregion
-//#region src/core/hls/parse-media-playlist.ts
-/**
-* Parse HLS media playlist and resolve track with segments.
-*
-* Takes an unresolved track (from multivariant playlist) and media playlist text,
-* returns a HAM-compliant resolved track with segments.
-*
-* @param text - Media playlist text content
-* @param unresolved - Unresolved track from parseMultivariantPlaylist
-* @returns Resolved track with segments (type inferred from input)
-*/
-function parseMediaPlaylist(text, unresolved) {
-	const lines = text.split(/\r?\n/);
-	const baseUrl = unresolved.url;
-	const segments = [];
-	let initSegmentUrl;
-	let initSegmentByteRange;
-	let currentDuration = 0;
-	let currentByteRange;
-	let currentTime = 0;
-	let segmentIndex = 0;
-	let previousByteRangeEnd;
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#") && !trimmed.startsWith("#EXT")) continue;
-		if (trimmed === "#EXTM3U" || trimmed.startsWith("#EXT-X-VERSION:") || trimmed.startsWith("#EXT-X-TARGETDURATION:") || trimmed.startsWith("#EXT-X-PLAYLIST-TYPE:") || trimmed.startsWith("#EXT-X-INDEPENDENT-SEGMENTS")) continue;
-		const mapAttrs = matchTag(trimmed, "EXT-X-MAP");
-		if (mapAttrs) {
-			const uri = mapAttrs.get("URI");
-			if (uri) {
-				initSegmentUrl = resolveUrl(uri, baseUrl);
-				const byteRangeStr = mapAttrs.get("BYTERANGE");
-				if (byteRangeStr) initSegmentByteRange = parseByteRange(byteRangeStr, 0) ?? void 0;
-			}
-			continue;
-		}
-		if (trimmed.startsWith("#EXTINF:")) {
-			currentDuration = parseExtInfDuration(trimmed.slice(8));
-			continue;
-		}
-		if (trimmed.startsWith("#EXT-X-BYTERANGE:")) {
-			currentByteRange = parseByteRange(trimmed.slice(17), previousByteRangeEnd) ?? void 0;
-			continue;
-		}
-		if (trimmed === "#EXT-X-ENDLIST") continue;
-		if (!trimmed.startsWith("#") && currentDuration > 0) {
-			const segment = {
-				id: `segment-${segmentIndex}`,
-				url: resolveUrl(trimmed, baseUrl),
-				duration: currentDuration,
-				startTime: currentTime
-			};
-			if (currentByteRange) {
-				segment.byteRange = currentByteRange;
-				previousByteRangeEnd = currentByteRange.end + 1;
-			} else previousByteRangeEnd = void 0;
-			segments.push(segment);
-			currentTime += currentDuration;
-			segmentIndex++;
-			currentDuration = 0;
-			currentByteRange = void 0;
-		}
-	}
-	const totalDuration = currentTime;
-	const initialization = unresolved.type === "text" && !initSegmentUrl ? void 0 : initSegmentUrl ? {
-		url: initSegmentUrl,
-		...initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}
-	} : { url: "" };
-	return {
-		...unresolved,
-		startTime: 0,
-		duration: totalDuration,
-		segments,
-		initialization
-	};
-}
-
-//#endregion
-//#region src/core/utils/generate-id.ts
-/**
-* Generate unique ID for HAM objects.
-*
-* Uses timestamp + random number for sufficient uniqueness.
-* IDs are strings without decimals.
-*
-* @returns Unique string ID in format: timestamp-random
-*
-* @example
-* ```ts
-* const id = generateId();  // "1738423156789-542891"
-* ```
-*/
-function generateId() {
-	return `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
-}
-
-//#endregion
-//#region src/core/hls/parse-multivariant.ts
-/**
-* Parse HLS multivariant playlist into a Presentation.
-*
-* Returns Presentation with partially resolved tracks (no segment information).
-* Tracks contain metadata from multivariant playlist (bandwidth, resolution, codecs)
-* but segment information is added when media playlists are fetched.
-*
-* @param text - Raw playlist text content
-* @param unresolved - Unresolved presentation (contains URL for base URL resolution)
-* @returns Presentation with partially resolved tracks (duration is undefined)
-*/
-function parseMultivariantPlaylist(text, unresolved) {
-	const baseUrl = unresolved.url;
-	const lines = text.split(/\r?\n/);
-	const streams = [];
-	const audioRenditions = [];
-	const subtitleRenditions = [];
-	let pendingStreamInfo = null;
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#") && !trimmed.startsWith("#EXT")) continue;
-		if (trimmed === "#EXTM3U" || trimmed.startsWith("#EXT-X-VERSION:") || trimmed.startsWith("#EXT-X-INDEPENDENT-SEGMENTS")) continue;
-		const mediaAttrs = matchTag(trimmed, "EXT-X-MEDIA");
-		if (mediaAttrs) {
-			const type = mediaAttrs.get("TYPE");
-			const groupId = mediaAttrs.get("GROUP-ID");
-			const name = mediaAttrs.get("NAME");
-			if (type === "AUDIO" && groupId && name) {
-				const uri = mediaAttrs.get("URI");
-				audioRenditions.push({
-					groupId,
-					name,
-					language: mediaAttrs.get("LANGUAGE"),
-					uri: uri ? resolveUrl(uri, baseUrl) : void 0,
-					default: mediaAttrs.getBool("DEFAULT"),
-					autoselect: mediaAttrs.getBool("AUTOSELECT")
-				});
-			}
-			if (type === "SUBTITLES" && groupId && name) {
-				const uri = mediaAttrs.get("URI");
-				if (uri) subtitleRenditions.push({
-					groupId,
-					name,
-					language: mediaAttrs.get("LANGUAGE"),
-					uri: resolveUrl(uri, baseUrl),
-					default: mediaAttrs.getBool("DEFAULT"),
-					autoselect: mediaAttrs.getBool("AUTOSELECT"),
-					forced: mediaAttrs.getBool("FORCED")
-				});
-			}
-			continue;
-		}
-		const streamInfAttrs = matchTag(trimmed, "EXT-X-STREAM-INF");
-		if (streamInfAttrs) {
-			pendingStreamInfo = {
-				bandwidth: streamInfAttrs.getInt("BANDWIDTH", 0),
-				resolution: streamInfAttrs.getResolution("RESOLUTION"),
-				codecs: streamInfAttrs.get("CODECS"),
-				frameRate: streamInfAttrs.getFrameRate("FRAME-RATE"),
-				audioGroupId: streamInfAttrs.get("AUDIO")
-			};
-			continue;
-		}
-		if (!trimmed.startsWith("#") && pendingStreamInfo) {
-			streams.push({
-				...pendingStreamInfo,
-				uri: resolveUrl(trimmed, baseUrl)
-			});
-			pendingStreamInfo = null;
-		}
-	}
-	const videoStreams = [];
-	const audioOnlyStreams = [];
-	for (const stream of streams) {
-		if (!stream.codecs) {
-			videoStreams.push(stream);
-			continue;
-		}
-		const parsedCodecs = parseCodecs(stream.codecs);
-		if (stream.codecs.split(",").length === 1) if (parsedCodecs.audio && !parsedCodecs.video) audioOnlyStreams.push(stream);
-		else videoStreams.push(stream);
-		else videoStreams.push(stream);
-	}
-	const videoTracks = videoStreams.map((stream) => {
-		const codecs = stream.codecs ? parseCodecs(stream.codecs) : void 0;
-		const track = {
-			type: "video",
-			id: generateId(),
-			url: stream.uri,
-			bandwidth: stream.bandwidth,
-			mimeType: "video/mp4",
-			codecs: []
-		};
-		if (stream.resolution?.width !== void 0) track.width = stream.resolution.width;
-		if (stream.resolution?.height !== void 0) track.height = stream.resolution.height;
-		if (codecs?.video) track.codecs = [codecs.video];
-		if (stream.frameRate) track.frameRate = stream.frameRate;
-		if (stream.audioGroupId) track.audioGroupId = stream.audioGroupId;
-		return track;
-	});
-	const audioOnlyTracks = audioOnlyStreams.map((stream) => {
-		const codecs = stream.codecs ? parseCodecs(stream.codecs) : void 0;
-		return {
-			type: "audio",
-			id: generateId(),
-			url: stream.uri,
-			bandwidth: stream.bandwidth,
-			mimeType: "audio/mp4",
-			codecs: codecs?.audio ? [codecs.audio] : [],
-			groupId: stream.audioGroupId || "default",
-			name: "Default",
-			sampleRate: 48e3,
-			channels: 2
-		};
-	});
-	const audioTracks = [...audioRenditions.map((rendition) => {
-		let audioCodecs;
-		for (const stream of streams) if (stream.audioGroupId === rendition.groupId && stream.codecs) {
-			const codecs = parseCodecs(stream.codecs);
-			if (codecs.audio) {
-				audioCodecs = [codecs.audio];
-				break;
-			}
-		}
-		const track = {
-			type: "audio",
-			id: generateId(),
-			url: rendition.uri ?? "",
-			groupId: rendition.groupId,
-			name: rendition.name,
-			mimeType: "audio/mp4",
-			bandwidth: 0,
-			sampleRate: 48e3,
-			channels: 2,
-			codecs: []
-		};
-		if (rendition.language) track.language = rendition.language;
-		if (audioCodecs) track.codecs = audioCodecs;
-		if (rendition.default) track.default = rendition.default;
-		if (rendition.autoselect) track.autoselect = rendition.autoselect;
-		return track;
-	}), ...audioOnlyTracks];
-	const textTracks = subtitleRenditions.map((rendition) => {
-		const track = {
-			type: "text",
-			id: generateId(),
-			url: rendition.uri,
-			groupId: rendition.groupId,
-			label: rendition.name,
-			kind: "subtitles",
-			mimeType: "text/vtt",
-			bandwidth: 0
-		};
-		if (rendition.language) track.language = rendition.language;
-		if (rendition.default && rendition.autoselect) track.default = true;
-		if (rendition.autoselect) track.autoselect = rendition.autoselect;
-		if (rendition.forced) track.forced = rendition.forced;
-		return track;
-	});
-	const selectionSets = [];
-	if (videoTracks.length > 0) {
-		const videoSwitchingSet = {
-			id: generateId(),
-			type: "video",
-			tracks: videoTracks
-		};
-		const videoSelectionSet = {
-			id: generateId(),
-			type: "video",
-			switchingSets: [videoSwitchingSet]
-		};
-		selectionSets.push(videoSelectionSet);
-	}
-	if (audioTracks.length > 0) {
-		const audioSwitchingSet = {
-			id: generateId(),
-			type: "audio",
-			tracks: audioTracks
-		};
-		const audioSelectionSet = {
-			id: generateId(),
-			type: "audio",
-			switchingSets: [audioSwitchingSet]
-		};
-		selectionSets.push(audioSelectionSet);
-	}
-	if (textTracks.length > 0) {
-		const textSwitchingSet = {
-			id: generateId(),
-			type: "text",
-			tracks: textTracks
-		};
-		const textSelectionSet = {
-			id: generateId(),
-			type: "text",
-			switchingSets: [textSwitchingSet]
-		};
-		selectionSets.push(textSelectionSet);
-	}
-	return {
-		id: generateId(),
-		url: unresolved.url,
-		startTime: 0,
-		selectionSets
-	};
-}
-
-//#endregion
-//#region src/core/abr/ewma.ts
-/**
-* Exponentially Weighted Moving Average (EWMA)
-*
-* Pure functional implementation of EWMA calculations.
-* Based on Shaka Player's EWMA algorithm.
-*/
-/**
-* Calculate alpha (decay factor) from half-life.
-*
-* Alpha determines how quickly old data "expires":
-* - alpha close to 1 = slow decay (long memory)
-* - alpha close to 0 = fast decay (short memory)
-*
-* @param halfLife - The quantity of prior samples (by weight) that make up
-*   half of the new estimate. Must be positive.
-* @returns Alpha value between 0 and 1
-*
-* @example
-* const alpha = calculateAlpha(2); // ≈ 0.7071 for 2-second half-life
-*/
-function calculateAlpha(halfLife) {
-	return Math.exp(Math.log(.5) / halfLife);
-}
-/**
-* Calculate exponentially weighted moving average.
-*
-* Updates an estimate by blending a new value with the previous estimate,
-* weighted by the sample duration. Longer samples have more influence.
-*
-* @param prevEstimate - Previous EWMA estimate
-* @param value - New sample value to incorporate
-* @param weight - Sample weight (typically duration in seconds)
-* @param halfLife - Half-life for decay (typically 2-5 seconds)
-* @returns Updated EWMA estimate
-*
-* @example
-* let estimate = 0;
-* estimate = calculateEwma(estimate, 1_000_000, 1, 2); // First sample
-* estimate = calculateEwma(estimate, 2_000_000, 1, 2); // Second sample
-*/
-function calculateEwma(prevEstimate, value, weight, halfLife) {
-	const adjAlpha = calculateAlpha(halfLife) ** weight;
-	return value * (1 - adjAlpha) + adjAlpha * prevEstimate;
-}
-/**
-* Apply zero-factor correction to EWMA estimate.
-*
-* The zero-factor correction compensates for bias when starting from zero.
-* Without this correction, early estimates would be artificially low.
-*
-* As totalWeight increases, the correction factor approaches 1, meaning
-* the estimate becomes more reliable and needs less correction.
-*
-* @param estimate - Raw EWMA estimate (uncorrected)
-* @param totalWeight - Accumulated weight from all samples
-* @param halfLife - Half-life used in EWMA calculation
-* @returns Corrected estimate, or 0 if totalWeight is 0
-*
-* @example
-* const raw = calculateEwma(0, 1_000_000, 1, 2);
-* const corrected = applyZeroFactor(raw, 1, 2); // ≈ 1_000_000
-*/
-function applyZeroFactor(estimate, totalWeight, halfLife) {
-	if (totalWeight === 0) return 0;
-	return estimate / (1 - calculateAlpha(halfLife) ** totalWeight);
-}
-
-//#endregion
-//#region src/core/abr/bandwidth-estimator.ts
-/**
-* Default bandwidth estimator configuration.
-*
-* Values match Shaka Player defaults based on experimentation.
-*/
-const DEFAULT_BANDWIDTH_CONFIG = {
-	fastHalfLife: 2,
-	slowHalfLife: 5,
-	minTotalBytes: 128e3,
-	minBytes: 16e3,
-	minDuration: 5
-};
-/**
-* Add a bandwidth sample from a segment download.
-*
-* Samples are filtered based on:
-* - Minimum bytes (filters TTFB-dominated small segments)
-* - Minimum duration (filters cached responses)
-*
-* Valid samples update both fast and slow EWMA estimates.
-*
-* @param state - Current estimator state
-* @param durationMs - Download duration in milliseconds
-* @param numBytes - Number of bytes downloaded
-* @param config - Optional estimator configuration (uses defaults if not provided)
-* @returns New estimator state with sample incorporated (or unchanged if filtered)
-*
-* @example
-* let state = { fastEstimate: 0, fastTotalWeight: 0, ... };
-* // Sample: 1MB in 1 second
-* state = sampleBandwidth(state, 1000, 1_000_000);
-*/
-function sampleBandwidth(state, durationMs, numBytes, config = DEFAULT_BANDWIDTH_CONFIG) {
-	const updatedBytesSampled = state.bytesSampled + numBytes;
-	if (numBytes < config.minBytes) return {
-		...state,
-		bytesSampled: updatedBytesSampled
-	};
-	if (durationMs < config.minDuration) return {
-		...state,
-		bytesSampled: updatedBytesSampled
-	};
-	const bandwidth = 8e3 * numBytes / durationMs;
-	const weight = durationMs / 1e3;
-	return {
-		fastEstimate: calculateEwma(state.fastEstimate, bandwidth, weight, config.fastHalfLife),
-		fastTotalWeight: state.fastTotalWeight + weight,
-		slowEstimate: calculateEwma(state.slowEstimate, bandwidth, weight, config.slowHalfLife),
-		slowTotalWeight: state.slowTotalWeight + weight,
-		bytesSampled: updatedBytesSampled
-	};
-}
-/**
-* Get the current bandwidth estimate.
-*
-* Returns the **minimum** of the fast and slow EWMA estimates.
-* This provides the key asymmetric behavior:
-* - When bandwidth drops, fast EWMA reacts first and dominates (quick adaptation)
-* - When bandwidth rises, slow EWMA lags behind and dominates (slow adaptation)
-*
-* Uses default estimate until enough data has been sampled.
-*
-* @param state - Current estimator state
-* @param defaultEstimate - Fallback estimate before sufficient samples (bps)
-* @param config - Optional estimator configuration (uses defaults if not provided)
-* @returns Bandwidth estimate in bits per second
-*
-* @example
-* const estimate = getBandwidthEstimate(state, 5_000_000); // 5 Mbps default
-*/
-function getBandwidthEstimate(state, defaultEstimate, config = DEFAULT_BANDWIDTH_CONFIG) {
-	if (state.bytesSampled < config.minTotalBytes) return defaultEstimate;
-	const fastEstimate = applyZeroFactor(state.fastEstimate, state.fastTotalWeight, config.fastHalfLife);
-	const slowEstimate = applyZeroFactor(state.slowEstimate, state.slowTotalWeight, config.slowHalfLife);
-	return Math.min(fastEstimate, slowEstimate);
-}
-
-//#endregion
-//#region src/core/abr/quality-selection.ts
-/**
-* Default quality selection configuration.
-* Values match Shaka Player upgrade threshold (0.85 = 15% headroom).
-*/
-const DEFAULT_QUALITY_CONFIG = { safetyMargin: .85 };
-/**
-* Select the best video track based on current bandwidth estimate.
-*
-* Selects the highest quality track where bandwidth is sufficient with safety margin:
-* - currentBandwidth >= track.bandwidth / safetyMargin
-* - Default safetyMargin 0.85 means track uses ≤85% of bandwidth (15% headroom)
-* - At same bandwidth, prefers higher resolution
-*
-* @param tracks - Available video tracks (can be unsorted)
-* @param currentBandwidth - Current bandwidth estimate in bits per second
-* @param config - Optional quality selection configuration
-* @returns Selected track, or undefined if no tracks available
-*
-* @example
-* const tracks = [
-*   { id: '360p', bandwidth: 500_000, ... },
-*   { id: '720p', bandwidth: 2_000_000, ... },
-*   { id: '1080p', bandwidth: 4_000_000, ... },
-* ];
-*
-* // With 2.5 Mbps, selects 720p (1080p needs 4M/0.85 = 4.7 Mbps)
-* const selected = selectQuality(tracks, 2_500_000);
-*/
-function selectQuality(tracks, currentBandwidth, config = DEFAULT_QUALITY_CONFIG) {
-	if (tracks.length === 0) return;
-	const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);
-	let chosen;
-	for (const track of sortedTracks) if (currentBandwidth >= track.bandwidth / config.safetyMargin) {
-		if (!chosen || track.bandwidth > chosen.bandwidth || track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen)) chosen = track;
-	}
-	return chosen ?? sortedTracks[0];
-}
-/**
-* Check if track A has higher resolution than track B.
-* Compares by total pixel count (width × height).
-*
-* @param trackA - First track to compare
-* @param trackB - Second track to compare
-* @returns True if trackA has more pixels than trackB
-*/
-function hasHigherResolution(trackA, trackB) {
-	return (trackA.width ?? 0) * (trackA.height ?? 0) > (trackB.width ?? 0) * (trackB.height ?? 0);
-}
-
-//#endregion
-//#region src/core/buffer/back-buffer.ts
-/**
-* Default back buffer configuration.
-*/
-const DEFAULT_BACK_BUFFER_CONFIG = { keepSegments: 2 };
-/**
-* Calculate back buffer flush point.
-*
-* Determines where to flush old segments from the back buffer.
-* Keeps a fixed number of segments behind the current playback position.
-*
-* Algorithm:
-* 1. Find segments before currentTime
-* 2. Count back N segments (keepSegments)
-* 3. Return startTime of segment N+1 back (flush everything before this)
-*
-* @param segments - Available segments (should be sorted by startTime)
-* @param currentTime - Current playback position in seconds
-* @param config - Optional back buffer configuration
-* @returns Time in seconds to flush up to (flush range: [0, flushEnd))
-*
-* @example
-* const segments = [
-*   { startTime: 0, duration: 6, ... },
-*   { startTime: 6, duration: 6, ... },
-*   { startTime: 12, duration: 6, ... },
-*   { startTime: 18, duration: 6, ... },
-* ];
-*
-* // Playing at 18s, keep 2 segments
-* const flushEnd = calculateBackBufferFlushPoint(segments, 18);
-* // Returns 6 (flush [0, 6), keep [6-18))
-*/
-function calculateBackBufferFlushPoint(segments, currentTime, config = DEFAULT_BACK_BUFFER_CONFIG) {
-	if (segments.length === 0) return 0;
-	const segmentsBefore = segments.filter((seg) => seg.startTime < currentTime);
-	if (segmentsBefore.length === 0) return 0;
-	const segmentsToFlush = segmentsBefore.length - config.keepSegments;
-	if (segmentsToFlush <= 0) return 0;
-	if (segmentsToFlush >= segmentsBefore.length) return currentTime;
-	return segmentsBefore[segmentsToFlush].startTime;
-}
-
-//#endregion
-//#region src/core/buffer/forward-buffer.ts
-/**
-* Default forward buffer configuration.
-*/
-const DEFAULT_FORWARD_BUFFER_CONFIG = { bufferDuration: 30 };
-/**
-* Get segments that need to be loaded for forward buffer.
-*
-* Determines which segments to load to maintain target buffer duration.
-* Handles discontiguous buffering (gaps after seeks).
-*
-* Algorithm:
-* 1. Calculate target time: currentTime + bufferDuration
-* 2. Find all segments in range [currentTime, targetTime)
-* 3. Filter out segments already buffered at that time position
-* 4. Return segments to load (fills gaps + extends to target)
-*
-* @param segments - All available segments from playlist
-* @param bufferedSegments - Segments already buffered (ordered by startTime)
-* @param currentTime - Current playback position in seconds
-* @param config - Optional forward buffer configuration
-* @returns Array of segments to load (empty if buffer is sufficient)
-*
-* @example
-* // After seek: buffered [0-12, 18-30], playing at 7s
-* const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });
-* // Returns [seg-12, seg-30] (fills gap, extends to target 31s)
-*/
-/**
-* Calculate the start time from which to flush forward buffer content.
-*
-* Content that starts at or beyond `currentTime + bufferDuration` is no
-* longer needed for the current playback position and should be removed
-* from the SourceBuffer. This prevents unbounded accumulation of scattered
-* SourceBuffer content after seeks, which can cause QuotaExceededError on
-* long-form content.
-*
-* Returns `Infinity` when nothing needs flushing (no buffered segments
-* exist beyond the threshold).
-*
-* @param bufferedSegments - Segments currently tracked in the buffer model
-* @param currentTime - Current playback position in seconds
-* @param config - Optional forward buffer configuration
-* @returns Start time to flush from (flush range: [flushStart, Infinity)),
-*          or Infinity if no flush is needed
-*
-* @example
-* // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30
-* const flushStart = calculateForwardFlushPoint(segments, 0);
-* // Returns 30 — flush [30, Infinity), keep [0, 30)
-*/
-function calculateForwardFlushPoint(bufferedSegments, currentTime, config = DEFAULT_FORWARD_BUFFER_CONFIG) {
-	if (bufferedSegments.length === 0) return Infinity;
-	const threshold = currentTime + config.bufferDuration;
-	const beyond = bufferedSegments.filter((seg) => seg.startTime >= threshold);
-	if (beyond.length === 0) return Infinity;
-	return Math.min(...beyond.map((seg) => seg.startTime));
-}
-function getSegmentsToLoad(segments, bufferedSegments, currentTime, config = DEFAULT_FORWARD_BUFFER_CONFIG) {
-	if (segments.length === 0) return [];
-	const targetTime = currentTime + config.bufferDuration;
-	const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));
-	return segments.filter((seg) => {
-		const segmentEnd = seg.startTime + seg.duration;
-		const isInRange = seg.startTime < targetTime && segmentEnd > currentTime;
-		const isNotBuffered = !bufferedStartTimes.has(seg.startTime);
-		return isInRange && isNotBuffered;
-	});
-}
-
-//#endregion
-//#region src/core/types/index.ts
-function isResolvedTrack(track) {
-	return "segments" in track;
-}
-/**
-* Check if a presentation has duration (at least one track resolved).
-* Narrows type to include required duration.
-*/
-function hasPresentationDuration(presentation) {
-	return presentation.duration !== void 0;
-}
-
-//#endregion
-//#region src/dom/media/mediasource-setup.ts
-/**
-* MediaSource Setup
-*
-* Utilities for creating and configuring MediaSource/ManagedMediaSource
-* for MSE (Media Source Extensions) playback.
-*
-* Global ManagedMediaSource types are defined in ./mediasource.d.ts
-*/
-/**
-* Check if MediaSource API is supported.
-*/
-function supportsMediaSource() {
-	return typeof MediaSource !== "undefined";
-}
-/**
-* Check if ManagedMediaSource API is supported.
-* ManagedMediaSource is a newer Safari API with better lifecycle management.
-*/
-function supportsManagedMediaSource() {
-	return typeof ManagedMediaSource !== "undefined";
-}
-/**
-* Create a MediaSource or ManagedMediaSource instance.
-*
-* @param options - Creation options
-* @returns A MediaSource or ManagedMediaSource instance
-* @throws Error if no MediaSource API is available
-*
-* @example
-* const mediaSource = createMediaSource();
-* const mediaElement = document.querySelector('video');
-* attachMediaSource(mediaSource, mediaElement);
-*/
-function createMediaSource(options = {}) {
-	const { preferManaged = false } = options;
-	if (preferManaged && supportsManagedMediaSource()) return new ManagedMediaSource();
-	if (supportsMediaSource()) return new MediaSource();
-	throw new Error("MediaSource API is not supported");
-}
-/**
-* Attach a MediaSource to an HTMLMediaElement.
-*
-* Uses srcObject for ManagedMediaSource (Safari), or createObjectURL for regular MediaSource.
-*
-* @param mediaSource - The MediaSource to attach
-* @param mediaElement - The media element to attach to
-* @returns Object with URL and detach function
-*
-* @example
-* const mediaSource = createMediaSource();
-* const { detach } = attachMediaSource(mediaSource, videoElement);
-* await waitForSourceOpen(mediaSource);
-* // Use mediaSource...
-* // Later, to clean up:
-* detach();
-*/
-function attachMediaSource(mediaSource, mediaElement) {
-	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) {
-		mediaElement.disableRemotePlayback = true;
-		mediaElement.srcObject = mediaSource;
-		const detach$1 = () => {
-			mediaElement.srcObject = null;
-			mediaElement.load();
-		};
-		return {
-			url: "",
-			detach: detach$1
-		};
-	}
-	const url = URL.createObjectURL(mediaSource);
-	mediaElement.src = url;
-	const detach = () => {
-		mediaElement.removeAttribute("src");
-		mediaElement.load();
-		URL.revokeObjectURL(url);
-	};
-	return {
-		url,
-		detach
-	};
-}
-/**
-* Wait for a MediaSource to reach the 'open' state.
-* Resolves immediately if already open.
-*
-* @param mediaSource - The MediaSource to wait for
-* @param signal - Optional AbortSignal for cancellation
-* @returns Promise that resolves when the MediaSource is open
-*
-* @example
-* const mediaSource = createMediaSource();
-* attachMediaSource(mediaSource, videoElement);
-* await waitForSourceOpen(mediaSource);
-* // MediaSource is now ready for SourceBuffer creation
-*/
-function waitForSourceOpen(mediaSource, signal) {
-	return new Promise((resolve, reject) => {
-		if (mediaSource.readyState === "open") {
-			resolve();
-			return;
-		}
-		if (signal?.aborted) {
-			reject(new DOMException("Aborted", "AbortError"));
-			return;
-		}
-		const controller = new AbortController();
-		const options = { signal: controller.signal };
-		mediaSource.addEventListener("sourceopen", () => {
-			controller.abort();
-			resolve();
-		}, options);
-		signal?.addEventListener("abort", () => {
-			controller.abort();
-			reject(new DOMException("Aborted", "AbortError"));
-		}, options);
-	});
-}
-/**
-* Create a SourceBuffer on a MediaSource.
-*
-* @param mediaSource - The MediaSource (must be in 'open' state)
-* @param mimeCodec - MIME type with codecs (e.g., 'video/mp4; codecs="avc1.42E01E"')
-* @returns The created SourceBuffer
-* @throws Error if MediaSource is not open or codec is unsupported
-*
-* @example
-* await waitForSourceOpen(mediaSource);
-* const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs="avc1.42E01E"');
-*/
-function createSourceBuffer(mediaSource, mimeCodec) {
-	if (mediaSource.readyState !== "open") throw new Error("MediaSource is not open");
-	if (!isCodecSupported(mimeCodec)) throw new Error(`Codec not supported: ${mimeCodec}`);
-	return mediaSource.addSourceBuffer(mimeCodec);
-}
-/**
-* Check if a codec is supported.
-*
-* @param mimeCodec - MIME type with codecs string
-* @returns True if the codec is supported
-*
-* @example
-* if (isCodecSupported('video/mp4; codecs="avc1.42E01E"')) {
-*   // Create source buffer
-* }
-*/
-function isCodecSupported(mimeCodec) {
-	if (!supportsMediaSource()) return false;
-	return MediaSource.isTypeSupported(mimeCodec);
-}
-
-//#endregion
-//#region src/dom/network/chunked-stream-iterable.ts
-const DEFAULT_MIN_CHUNK_SIZE = 2 ** 17;
-/**
-* Adapts a `ReadableStream<Uint8Array>` (e.g. `response.body`) into an
-* `AsyncIterable<Uint8Array>` that yields chunks no smaller than
-* `minChunkSize` bytes. Smaller network chunks are accumulated and yielded
-* together once the threshold is met. Any remainder is flushed on stream end.
-*
-* Errors from the underlying stream propagate naturally — the reader lock is
-* always released via `finally`.
-*/
-var ChunkedStreamIterable = class {
-	minChunkSize;
-	#readableStream;
-	constructor(readableStream, { minChunkSize = DEFAULT_MIN_CHUNK_SIZE } = {}) {
-		this.#readableStream = readableStream;
-		this.minChunkSize = minChunkSize;
-	}
-	async *[Symbol.asyncIterator]() {
-		let pending;
-		const reader = this.#readableStream.getReader();
-		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) {
-					if (pending) yield pending;
-					break;
-				}
-				pending = pending ? concat(pending, value) : value;
-				if (pending.length >= this.minChunkSize) {
-					yield pending;
-					pending = void 0;
-				}
-			}
-		} finally {
-			reader.releaseLock();
-		}
-	}
-};
-function concat(a, b) {
-	const result = new Uint8Array(a.length + b.length);
-	result.set(a);
-	result.set(b, a.length);
-	return result;
-}
-
-//#endregion
-//#region src/dom/network/fetch.ts
-/**
-* Fetch resolvable from AddressableObject.
-*
-* Handles byte range requests if byteRange is present.
-* Returns native fetch Response for composability (can extract text, stream, etc.).
-*
-* @param addressable - Resource to fetch (url + optional byteRange)
-* @returns Promise resolving to Response
-*
-* @example
-* const response = await fetchResolvable({ url: 'https://example.com/segment.m4s' });
-* const text = await getResponseText(response);
-*
-* @example
-* // With byte range
-* const response = await fetchResolvable({
-*   url: 'https://example.com/file.mp4',
-*   byteRange: { start: 1000, end: 1999 }
-* });
-*/
-async function fetchResolvable(addressable, options) {
-	const headers = new Headers(options?.headers);
-	if (addressable.byteRange) {
-		const { start, end } = addressable.byteRange;
-		headers.set("Range", `bytes=${start}-${end}`);
-	}
-	const request = new Request(addressable.url, {
-		method: "GET",
-		headers,
-		...options
-	});
-	return fetch(request);
-}
-/**
-* Extract text from Response.
-*
-* Accepts minimal Response-like object (just needs text() method).
-* Returns promise from response.text().
-*
-* @param response - Response-like object with text() method
-* @returns Promise resolving to text content
-*
-* @example
-* const response = await fetchResolvable(addressable);
-* const text = await getResponseText(response);
-*/
-function getResponseText(response) {
-	return response.text();
-}
-
-//#endregion
-//#region src/core/events/create-event-stream.ts
-/**
-* Minimal event stream with Observable-like shape.
-*
-* Simple Subject/Observable-like implementation for dispatching discrete events.
-* Events are dispatched synchronously to all subscribers.
-*/
-const EVENT_STREAM_SYMBOL = Symbol("@videojs/event-stream");
-/**
-* Creates a minimal event stream for dispatching discrete events.
-*
-* Events are dispatched synchronously to all subscribers.
-* Conforms to Observable-like shape for future compatibility.
-*
-* Events must have a 'type' property for discriminated union type narrowing.
-*
-* @example
-* ```ts
-* type Action = { type: 'PLAY' } | { type: 'PAUSE' };
-* const events = createEventStream<Action>();
-*
-* events.subscribe((action) => {
-*   if (action.type === 'PLAY') {
-*     // Type narrowed to { type: 'PLAY' }
-*   }
-* });
-*
-* events.dispatch({ type: 'PLAY' });
-* ```
-*/
-function createEventStream() {
-	const subscribers = /* @__PURE__ */ new Set();
-	return {
-		[EVENT_STREAM_SYMBOL]: true,
-		dispatch(event) {
-			const current = Array.from(subscribers);
-			for (const listener of current) listener(event);
-		},
-		subscribe(listener) {
-			subscribers.add(listener);
-			return () => subscribers.delete(listener);
-		}
-	};
-}
-
-//#endregion
-//#region src/core/reactive/combine-latest.ts
-/**
-* Combines multiple Observable sources into a single Observable.
-*
-* Emits an array of latest values whenever any source emits.
-* Only emits after all sources have emitted at least once.
-*
-* Supports selector-based subscriptions (fires only when the selected value
-* changes, per the optional equalityFn) mirroring the createState API.
-*
-* @param sources - Array of Observable sources
-* @returns Combined Observable
-*
-* @example
-* ```ts
-* const state = createState({ count: 0 });
-* const events = createEventStream<Action>();
-*
-* combineLatest([state, events]).subscribe(([state, event]) => {
-*   if (event.type === 'PLAY' && state.count > 0) {
-*     // React to event + state condition
-*   }
-* });
-* ```
-*
-* @example Selector subscription
-* ```ts
-* combineLatest([state, owners]).subscribe(
-*   ([s, o]) => deriveKey(s, o),
-*   (key) => { ... },
-*   { equalityFn: keyEq }
-* );
-* ```
-*/
-function combineLatest(sources) {
-	const subscribeToSources = (listener) => {
-		const latest = new Array(sources.length);
-		const hasValue = new Array(sources.length).fill(false);
-		const unsubscribers = [];
-		for (let i = 0; i < sources.length; i++) {
-			const unsubscribe = sources[i].subscribe((value) => {
-				latest[i] = value;
-				hasValue[i] = true;
-				if (hasValue.every((has) => has)) listener([...latest]);
-			});
-			unsubscribers.push(unsubscribe);
-		}
-		return () => {
-			for (const unsubscribe of unsubscribers) unsubscribe();
-		};
-	};
-	return { subscribe(listenerOrSelector, maybeListener, options) {
-		if (maybeListener === void 0) return subscribeToSources(listenerOrSelector);
-		const selector = listenerOrSelector;
-		const listener = maybeListener;
-		const equalityFn = options?.equalityFn ?? Object.is;
-		let prevSelected;
-		let initialized = false;
-		return subscribeToSources((values) => {
-			const nextSelected = selector(values);
-			if (!initialized || !equalityFn(prevSelected, nextSelected)) {
-				prevSelected = nextSelected;
-				initialized = true;
-				listener(nextSelected);
-			}
-		});
-	} };
-}
-
-//#endregion
-//#region src/core/features/resolve-presentation.ts
-/**
-* Type guard to check if presentation is unresolved.
-*/
-function isUnresolved(presentation) {
-	return presentation !== void 0 && "url" in presentation && !("id" in presentation);
-}
-function canResolve$1(state) {
-	return isUnresolved(state.presentation);
-}
-/**
-* Determines if resolution conditions are met based on preload policy and event.
-*
-* Resolution conditions:
-* - State-driven: preload is 'auto' or 'metadata'
-* - Event-driven: play event
-*
-* @param state - Current presentation state
-* @param event - Current action/event
-* @returns true if resolution conditions are met
-*/
-function shouldResolve$1(state, event) {
-	const { preload } = state;
-	return ["auto", "metadata"].includes(preload) || event.type === "play";
-}
-/**
-* Syncs preload attribute from mediaElement to state.
-*
-* Watches the owners state for mediaElement changes and copies the
-* preload attribute to the immutable state.
-*
-* @param state - Immutable state container
-* @param owners - Mutable platform objects container
-* @returns Cleanup function to stop syncing
-*/
-function syncPreloadAttribute(state, owners) {
-	return owners.subscribe((current) => {
-		const preload = current.mediaElement?.preload || void 0;
-		state.patch({ preload });
-	});
-}
-/**
-* Resolves unresolved presentations using reactive composition.
-*
-* Uses combineLatest to compose state + events, enabling both state-driven
-* and event-driven resolution triggers.
-*
-* Triggers resolution when:
-* - State-driven: Unresolved presentation + preload allows (auto/metadata)
-* - Event-driven: PLAY event when preload="none"
-*
-* @example
-* ```ts
-* const state = createState({ presentation: undefined, preload: 'auto' });
-* const events = createEventStream<PresentationAction>();
-*
-* const cleanup = resolvePresentation({ state, events });
-*
-* // State-driven: resolves immediately when preload allows
-* state.patch({ presentation: { url: 'http://example.com/playlist.m3u8' } });
-*
-* // Event-driven: resolves on PLAY when preload="none"
-* state.patch({ preload: 'none', presentation: { url: '...' } });
-* events.dispatch({ type: 'PLAY' });
-* ```
-*/
-function resolvePresentation({ state, events }) {
-	let resolving = false;
-	let abortController = null;
-	const cleanup = combineLatest([state, events]).subscribe(async ([currentState, event]) => {
-		if (!canResolve$1(currentState) || !shouldResolve$1(currentState, event) || resolving) return;
-		try {
-			resolving = true;
-			abortController = new AbortController();
-			const { presentation } = currentState;
-			const parsed = parseMultivariantPlaylist(await getResponseText(await fetchResolvable(presentation, { signal: abortController.signal })), presentation);
-			state.patch({ presentation: parsed });
-		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") return;
-			throw error;
-		} finally {
-			resolving = false;
-			abortController = null;
-		}
-	});
-	return () => {
-		abortController?.abort();
-		cleanup();
-	};
-}
-
-//#endregion
-//#region src/core/features/quality-switching.ts
-/**
-* Default quality switching configuration.
-*/
-const DEFAULT_SWITCHING_CONFIG = {
-	safetyMargin: .85,
-	minUpgradeInterval: 8e3,
-	defaultBandwidth: 5e6
-};
-/**
-* Get all video tracks from a presentation's first switching set.
-* Returns [] when the presentation is still unresolved (no selectionSets yet).
-*/
-function getVideoTracks(presentation) {
-	return (presentation.selectionSets?.find((s) => s.type === "video"))?.switchingSets[0]?.tracks ?? [];
-}
-/**
-* Quality switching orchestration (F9).
-*
-* Reacts to bandwidth estimate changes and updates `selectedVideoTrackId`
-* when a different quality is optimal:
-*
-* - **Downgrades** happen immediately to avoid buffering stalls.
-* - **Upgrades** are gated by `minUpgradeInterval` to prevent oscillation.
-* - The first switch (from any track, or no track) is always immediate.
-*
-* Smooth switching is handled downstream: when `selectedVideoTrackId` changes,
-* `resolveTrack` fetches the new playlist and `loadSegments` reloads the init
-* segment, then appends media segments from the current position in the new
-* quality. The browser's SourceBuffer replaces the overlapping buffered range.
-*
-* @example
-* const cleanup = switchQuality({ state });
-* // Later, when done:
-* cleanup();
-*/
-function switchQuality({ state }, config = {}) {
-	const safetyMargin = config.safetyMargin ?? DEFAULT_SWITCHING_CONFIG.safetyMargin;
-	const minUpgradeInterval = config.minUpgradeInterval ?? DEFAULT_SWITCHING_CONFIG.minUpgradeInterval;
-	const defaultBandwidth = config.defaultBandwidth ?? DEFAULT_SWITCHING_CONFIG.defaultBandwidth;
-	let lastUpgradeTime = Date.now();
-	let firstMeaningfulFire = true;
-	return state.subscribe((currentState) => {
-		const { presentation, bandwidthState, selectedVideoTrackId, abrDisabled } = currentState;
-		if (abrDisabled === true) return;
-		if (!presentation || !bandwidthState) return;
-		const videoTracks = getVideoTracks(presentation);
-		if (videoTracks.length === 0) return;
-		const isFirst = firstMeaningfulFire;
-		firstMeaningfulFire = false;
-		const optimal = selectQuality(videoTracks, getBandwidthEstimate(bandwidthState, defaultBandwidth), { safetyMargin });
-		if (!optimal || optimal.id === selectedVideoTrackId) return;
-		const currentTrack = videoTracks.find((t) => t.id === selectedVideoTrackId);
-		if (!currentTrack || optimal.bandwidth > currentTrack.bandwidth) {
-			const now = Date.now();
-			if (!isFirst && now - lastUpgradeTime < minUpgradeInterval) return;
-			lastUpgradeTime = now;
-		}
-		state.patch({ selectedVideoTrackId: optimal.id });
-	});
-}
-
-//#endregion
-//#region src/core/utils/track-selection.ts
-/**
-* Map track type to selected track ID property key in state.
-*/
-const SelectedTrackIdKeyByType = {
-	video: "selectedVideoTrackId",
-	audio: "selectedAudioTrackId",
-	text: "selectedTextTrackId"
-};
-/**
-* Get selected track from state by type.
-* Returns properly typed track (partially or fully resolved) or undefined.
-* Type parameter T is inferred from the type argument.
-*
-* @example
-* const videoTrack = getSelectedTrack(state, 'video');
-* if (videoTrack && isResolvedTrack(videoTrack)) {
-*   // videoTrack is VideoTrack
-* }
-*/
-function getSelectedTrack(state, type) {
-	const { presentation } = state;
-	/** @TODO Consider moving and reusing isUnresolved(presentation) (CJP) */
-	if (!presentation || !("id" in presentation)) return void 0;
-	const trackId = state[SelectedTrackIdKeyByType[type]];
-	return presentation.selectionSets.find(({ type: selectionSetType }) => selectionSetType === type)?.switchingSets[0]?.tracks.find(({ id }) => id === trackId);
-}
-
-//#endregion
-//#region src/dom/features/segment-loader-actor.ts
-/**
-* Creates a SegmentLoaderActor for one track type (video or audio).
-*
-* Receives load assignments via `send()` and owns all execution: planning,
-* removes, fetches, and appends. Coordinates with the SourceBufferActor for
-* all physical SourceBuffer operations.
-*
-* Planning (Cases 1–3) happens in `send()` on every incoming message, producing
-* an ordered LoadTask list. The runner drains that list sequentially. When a new
-* message arrives mid-run, send() replans and either continues the in-flight
-* operation (if still needed) or preempts it.
-*
-* @param sourceBufferActor - Shared SourceBufferActor reference (not owned)
-* @param fetchBytes - Tracked fetch closure (owns throughput sampling for segments).
-*   Accepts an optional `minChunkSize` in options; init segments pass `Infinity`
-*   so the entire body accumulates as one chunk before appending.
-*/
-function createSegmentLoaderActor(sourceBufferActor, fetchBytes) {
-	let pendingTasks = null;
-	let inFlightInitTrackId = null;
-	let inFlightSegmentId = null;
-	let abortController = null;
-	let running = false;
-	let destroyed = false;
-	const getBufferedSegments = (allSegments) => {
-		const bufferedIds = new Set(sourceBufferActor.snapshot.context.segments.filter((s) => !s.partial).map((s) => s.id));
-		return allSegments.filter((s) => bufferedIds.has(s.id));
-	};
-	/**
-	* Translate a load message into an ordered LoadTask list based on committed
-	* actor state. In-flight awareness is handled separately in send().
-	*
-	* @todo Rename alongside LoadTask (e.g. planOps).
-	*
-	* Case 1 — Removes: forward and back buffer flush points, segment-aligned.
-	*   No flush on track switch: appending new content overwrites existing buffer
-	*   ranges, and the actor's time-aligned deduplication keeps the segment model
-	*   accurate as new segments arrive.
-	*
-	* Case 2 — Init: schedule if not yet committed for this track.
-	*
-	* Case 3 — Segments: all segments in the load window not yet committed.
-	*/
-	const planTasks = (message) => {
-		const { track, range } = message;
-		const actorCtx = sourceBufferActor.snapshot.context;
-		const bufferedSegments = getBufferedSegments(track.segments);
-		const currentTime = range?.start ?? 0;
-		const tasks = [];
-		if (range) {
-			const forwardFlushStart = calculateForwardFlushPoint(bufferedSegments, currentTime);
-			if (forwardFlushStart < Infinity) tasks.push({
-				type: "remove",
-				start: forwardFlushStart,
-				end: Infinity
-			});
-			const backFlushEnd = calculateBackBufferFlushPoint(bufferedSegments, currentTime);
-			if (backFlushEnd > 0) tasks.push({
-				type: "remove",
-				start: 0,
-				end: backFlushEnd
-			});
-		}
-		if (actorCtx.initTrackId !== track.id) tasks.push({
-			type: "append-init",
-			meta: { trackId: track.id },
-			url: track.initialization.url,
-			...track.initialization.byteRange !== void 0 && { byteRange: track.initialization.byteRange }
-		});
-		if (range) {
-			const EPSILON = 1e-4;
-			const segmentsToLoad = getSegmentsToLoad(track.segments, bufferedSegments, currentTime).filter((seg) => {
-				const existing = actorCtx.segments.find((s) => Math.abs(s.startTime - seg.startTime) < EPSILON);
-				if (existing?.partial) return true;
-				if (!existing?.trackBandwidth || !track.bandwidth) return true;
-				return track.bandwidth > existing.trackBandwidth;
-			});
-			for (const segment of segmentsToLoad) tasks.push({
-				type: "append-segment",
-				meta: {
-					id: segment.id,
-					startTime: segment.startTime,
-					duration: segment.duration,
-					trackId: track.id,
-					trackBandwidth: track.bandwidth
-				},
-				url: segment.url,
-				...segment.byteRange !== void 0 && { byteRange: segment.byteRange }
-			});
-		}
-		return tasks;
-	};
-	/**
-	* Execute a single LoadTask: fetch (if needed) then forward to SourceBufferActor.
-	* Sets/clears in-flight tracking around async operations so send() can make
-	* accurate continue/preempt decisions at any point during execution.
-	*
-	* @todo Rename alongside LoadTask (e.g. executeOp).
-	*/
-	const executeLoadTask = async (task) => {
-		const signal = abortController.signal;
-		try {
-			if (task.type === "remove") {
-				await sourceBufferActor.send(task, signal);
-				return;
-			}
-			if (task.type === "append-init") {
-				inFlightInitTrackId = task.meta.trackId;
-				if (!signal.aborted) {
-					const data = await fetchBytes(task, {
-						signal,
-						minChunkSize: Infinity
-					});
-					const isTrackSwitch = pendingTasks?.some((t) => t.type === "append-init" && t.meta.trackId !== task.meta.trackId);
-					if (!signal.aborted || !isTrackSwitch) {
-						const appendSignal = signal.aborted ? new AbortController().signal : signal;
-						await sourceBufferActor.send({
-							type: "append-init",
-							data,
-							meta: task.meta
-						}, appendSignal);
-					}
-				}
-				return;
-			}
-			inFlightSegmentId = task.meta.id;
-			if (!signal.aborted) {
-				const stream = await fetchBytes(task, { signal });
-				if (!signal.aborted) await sourceBufferActor.send({
-					type: "append-segment",
-					data: stream,
-					meta: task.meta
-				}, signal);
-			}
-		} finally {
-			inFlightInitTrackId = null;
-			inFlightSegmentId = null;
-		}
-	};
-	/**
-	* Drain the scheduled task list sequentially.
-	* After each task completes, checks for a pending replacement plan from send().
-	* If the signal was aborted and no new plan arrived, stops immediately.
-	*/
-	const runScheduled = async (initialTasks) => {
-		running = true;
-		abortController = new AbortController();
-		let scheduled = initialTasks;
-		while (scheduled.length > 0 && !destroyed) {
-			const task = scheduled[0];
-			scheduled = scheduled.slice(1);
-			try {
-				await executeLoadTask(task);
-			} catch (error) {
-				if (error instanceof Error && error.name === "AbortError") {} else {
-					console.error("Unexpected error in segment loader:", error);
-					scheduled = [];
-				}
-			}
-			if (pendingTasks !== null) {
-				scheduled = pendingTasks;
-				pendingTasks = null;
-				abortController = new AbortController();
-			} else if (abortController.signal.aborted) break;
-		}
-		abortController = null;
-		running = false;
-	};
-	return {
-		send(message) {
-			if (destroyed) return;
-			const allTasks = planTasks(message);
-			if (!running) {
-				if (allTasks.length === 0) return;
-				runScheduled(allTasks);
-				return;
-			}
-			if (inFlightSegmentId !== null && allTasks.some((t) => t.type === "append-segment" && t.meta.id === inFlightSegmentId) || inFlightInitTrackId !== null && allTasks.some((t) => t.type === "append-init" && t.meta.trackId === inFlightInitTrackId)) pendingTasks = allTasks.filter((t) => !(t.type === "append-segment" && t.meta.id === inFlightSegmentId) && !(t.type === "append-init" && t.meta.trackId === inFlightInitTrackId));
-			else {
-				pendingTasks = allTasks;
-				abortController?.abort();
-			}
-		},
-		destroy() {
-			destroyed = true;
-			abortController?.abort();
-		}
-	};
-}
-
-//#endregion
-//#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$1, state$1]) => selectLoadingInputs([segmentsCanLoad$1, state$1], 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
-//#region src/dom/text/parse-vtt-segment.ts
-/**
-* Parse a VTT segment using browser's native parser.
-*
-* Creates a dummy video element with a track element to leverage
-* the browser's optimized VTT parsing. Returns parsed VTTCue objects.
-*/
-let dummyVideo = null;
-function ensureDummyVideo() {
-	if (!dummyVideo) {
-		dummyVideo = document.createElement("video");
-		dummyVideo.muted = true;
-		dummyVideo.preload = "none";
-		dummyVideo.style.display = "none";
-		dummyVideo.crossOrigin = "anonymous";
-	}
-	return dummyVideo;
-}
-function parseVttSegment(url) {
-	const video = ensureDummyVideo();
-	const track = document.createElement("track");
-	track.kind = "subtitles";
-	track.default = true;
-	return new Promise((resolve, reject) => {
-		const onLoad = () => {
-			const cues = [];
-			const textTrack = track.track;
-			if (textTrack.cues) for (let i = 0; i < textTrack.cues.length; i++) {
-				const cue = textTrack.cues[i];
-				if (cue) cues.push(cue);
-			}
-			cleanup();
-			resolve(cues);
-		};
-		const onError = () => {
-			cleanup();
-			reject(/* @__PURE__ */ new Error(`Failed to load VTT segment: ${url}`));
-		};
-		const cleanup = () => {
-			track.removeEventListener("load", onLoad);
-			track.removeEventListener("error", onError);
-			video.removeChild(track);
-		};
-		track.addEventListener("load", onLoad);
-		track.addEventListener("error", onError);
-		video.appendChild(track);
-		track.src = url;
-	});
-}
-function destroyVttParser() {
-	dummyVideo = null;
-}
-
-//#endregion
-//#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
-//#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 unsubscribe = owners.subscribe((currentOwners) => {
-		const { mediaElement } = currentOwners;
-		if (mediaElement === lastMediaElement) return;
-		removeListeners?.();
-		removeListeners = null;
-		lastMediaElement = mediaElement;
-		if (!mediaElement) return;
-		state.patch({ currentTime: mediaElement.currentTime });
-		const sync = () => state.patch({ currentTime: mediaElement.currentTime });
-		const removeTimeupdate = listen(mediaElement, "timeupdate", sync);
-		const removeSeeking = listen(mediaElement, "seeking", sync);
-		removeListeners = () => {
-			removeTimeupdate();
-			removeSeeking();
-		};
-	});
-	return () => {
-		removeListeners?.();
-		unsubscribe();
-	};
-}
-
-//#endregion
-//#region src/dom/features/track-playback-initiated.ts
-/**
-* Track whether playback has been initiated by the user.
-*
-* Sets `state.playbackInitiated = true` when the media element fires a `play`
-* event (via `element.play()`, native controls, or autoplay) and simultaneously
-* dispatches `{ type: 'play' }` to the event stream so `resolvePresentation`
-* can react.
-*
-* Resets `state.playbackInitiated = false` when `presentation.url` changes,
-* so a new source with `preload="none"` won't load segments until play is
-* triggered again.
-*
-* This flag is used by `shouldLoadSegments` to allow segment loading after
-* play is initiated regardless of the initial `preload` setting — `preload`
-* is a startup hint, not a runtime gate.
-*
-* @example
-* const cleanup = trackPlaybackInitiated({ state, owners, events });
-*/
-function trackPlaybackInitiated({ state, owners, events }) {
-	let lastMediaElement;
-	let removeListener = null;
-	let lastPresentationUrl;
-	const unsubscribeState = state.subscribe((currentState) => {
-		const url = currentState.presentation?.url;
-		if (url !== lastPresentationUrl) {
-			if (lastPresentationUrl !== void 0) state.patch({ playbackInitiated: false });
-			lastPresentationUrl = url;
-		}
-	});
-	const unsubscribeOwners = owners.subscribe((currentOwners) => {
-		const { mediaElement } = currentOwners;
-		if (mediaElement === lastMediaElement) return;
-		removeListener?.();
-		removeListener = null;
-		lastMediaElement = mediaElement;
-		if (!mediaElement) return;
-		removeListener = listen(mediaElement, "play", () => {
-			state.patch({ playbackInitiated: true });
-			events.dispatch({ type: "play" });
-		});
-	});
-	return () => {
-		removeListener?.();
-		unsubscribeState();
-		unsubscribeOwners();
-	};
-}
-
-//#endregion
-//#region src/dom/media/append-segment.ts
-/**
-* Append media data to a SourceBuffer.
-*
-* Accepts either a full ArrayBuffer (single append) or an AsyncIterable of
-* Uint8Array chunks (one append per chunk, in order). Waits for `updateend`
-* between each call so appends are serialized correctly.
-*
-* Errors from the SourceBuffer (`error` event) or from the iterable are
-* propagated as rejections.
-*/
-async function appendSegment(sourceBuffer, data, signal) {
-	if (data instanceof ArrayBuffer) await appendChunk(sourceBuffer, data);
-	else for await (const chunk of data) {
-		if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
-		await appendChunk(sourceBuffer, chunk);
-	}
-}
-async function appendChunk(sourceBuffer, data) {
-	if (sourceBuffer.updating) await new Promise((resolve) => {
-		const onUpdateEnd = () => {
-			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
-			resolve();
-		};
-		sourceBuffer.addEventListener("updateend", onUpdateEnd);
-	});
-	return new Promise((resolve, reject) => {
-		const onUpdateEnd = () => {
-			cleanup();
-			resolve();
-		};
-		const onError = (event) => {
-			cleanup();
-			reject(/* @__PURE__ */ new Error(`SourceBuffer append error: ${event.type}`));
-		};
-		const cleanup = () => {
-			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
-			sourceBuffer.removeEventListener("error", onError);
-		};
-		sourceBuffer.addEventListener("updateend", onUpdateEnd);
-		sourceBuffer.addEventListener("error", onError);
-		try {
-			sourceBuffer.appendBuffer(data);
-		} catch (error) {
-			cleanup();
-			reject(error);
-		}
-	});
-}
-
-//#endregion
-//#region src/dom/media/buffer-flusher.ts
-/**
-* Buffer flusher helper (P12)
-*
-* Removes a time range from a SourceBuffer to manage memory.
-*/
-/**
-* Remove a time range from a SourceBuffer.
-*
-* Waits for the SourceBuffer to be ready (not updating), then removes
-* the specified range. Returns a promise that resolves when removal completes.
-*
-* @param sourceBuffer - The SourceBuffer to remove data from
-* @param start - Start of the time range to remove (seconds)
-* @param end - End of the time range to remove (seconds)
-* @returns Promise that resolves when removal completes
-*
-* @example
-* await flushBuffer(videoSourceBuffer, 0, 30);
-*/
-async function flushBuffer(sourceBuffer, start, end) {
-	if (sourceBuffer.updating) await new Promise((resolve) => {
-		const onUpdateEnd = () => {
-			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
-			resolve();
-		};
-		sourceBuffer.addEventListener("updateend", onUpdateEnd);
-	});
-	return new Promise((resolve, reject) => {
-		const onUpdateEnd = () => {
-			cleanup();
-			resolve();
-		};
-		const onError = (event) => {
-			cleanup();
-			reject(/* @__PURE__ */ new Error(`SourceBuffer remove error: ${event.type}`));
-		};
-		const cleanup = () => {
-			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
-			sourceBuffer.removeEventListener("error", onError);
-		};
-		sourceBuffer.addEventListener("updateend", onUpdateEnd);
-		sourceBuffer.addEventListener("error", onError);
-		try {
-			sourceBuffer.remove(start, end);
-		} catch (error) {
-			cleanup();
-			reject(error);
-		}
-	});
-}
-
-//#endregion
-//#region src/core/features/calculate-presentation-duration.ts
-/**
-* Check if we can calculate presentation duration (have required data).
-*/
-function canCalculateDuration(state) {
-	if (!state.presentation) return false;
-	return !!(state.selectedVideoTrackId || state.selectedAudioTrackId);
-}
-/**
-* Check if we should calculate presentation duration (conditions met).
-*/
-function shouldCalculateDuration(state) {
-	if (!canCalculateDuration(state)) return false;
-	const { presentation } = state;
-	if (presentation.duration !== void 0) return false;
-	const videoTrack = state.selectedVideoTrackId ? getSelectedTrack(state, "video") : void 0;
-	const audioTrack = state.selectedAudioTrackId ? getSelectedTrack(state, "audio") : void 0;
-	return !!(videoTrack && isResolvedTrack(videoTrack) || audioTrack && isResolvedTrack(audioTrack));
-}
-/**
-* Get duration from the first resolved track (prefer video, fallback to audio).
-*/
-function getDurationFromResolvedTracks(state) {
-	const videoTrack = state.selectedVideoTrackId ? getSelectedTrack(state, "video") : void 0;
-	if (videoTrack && isResolvedTrack(videoTrack)) return videoTrack.duration;
-	const audioTrack = state.selectedAudioTrackId ? getSelectedTrack(state, "audio") : void 0;
-	if (audioTrack && isResolvedTrack(audioTrack)) return audioTrack.duration;
-}
-/**
-* Calculate and set presentation duration from resolved tracks.
-*/
-function calculatePresentationDuration({ state }) {
-	return combineLatest([state]).subscribe(([currentState]) => {
-		if (!shouldCalculateDuration(currentState)) return;
-		const duration = getDurationFromResolvedTracks(currentState);
-		if (duration === void 0 || !Number.isFinite(duration)) return;
-		const { presentation } = currentState;
-		state.patch({ presentation: {
-			...presentation,
-			duration
-		} });
-	});
-}
-
-//#endregion
-//#region src/core/task.ts
-/**
-* Generic reusable task that wraps an async run function.
-*
-* Owns its own AbortController so it can always be aborted independently.
-* Optionally composes an external AbortSignal so that a parent's cancellation
-* propagates into the task's work without requiring the caller to track the
-* task separately.
-*
-* Ordering guarantee: `value` is written before `status` transitions to `'done'`;
-* `error` is written before `status` transitions to `'error'`. Any reader
-* observing `status === 'done'` is guaranteed `value` is already present.
-*/
-var Task = class {
-	id;
-	#runFn;
-	#abortController = new AbortController();
-	#signal;
-	#status = "pending";
-	#value = void 0;
-	#error = void 0;
-	constructor(runFn, config) {
-		this.#runFn = runFn;
-		const rawId = config?.id;
-		this.id = typeof rawId === "function" ? rawId() : rawId ?? generateId();
-		this.#signal = config?.signal ? AbortSignal.any([this.#abortController.signal, config.signal]) : this.#abortController.signal;
-	}
-	get status() {
-		return this.#status;
-	}
-	get value() {
-		return this.#value;
-	}
-	get error() {
-		return this.#error;
-	}
-	async run() {
-		this.#status = "running";
-		try {
-			const result = await this.#runFn(this.#signal);
-			this.#value = result;
-			this.#status = "done";
-			return result;
-		} catch (e) {
-			this.#error = e;
-			this.#status = "error";
-			throw e;
-		}
-	}
-	abort() {
-		this.#abortController.abort();
-	}
-};
-/**
-* Runs tasks concurrently, deduplicated by task id.
-*
-* If a task with a given id is already in flight, subsequent schedule() calls
-* for that id are silently ignored until the first completes. Tasks are stored
-* so abortAll() can cancel any in-flight work (e.g. on engine cleanup).
-*/
-var ConcurrentRunner = class {
-	#pending = /* @__PURE__ */ new Map();
-	schedule(task) {
-		if (this.#pending.has(task.id)) return;
-		this.#pending.set(task.id, task);
-		task.run().catch((error) => {
-			if (!(error instanceof Error && error.name === "AbortError")) throw error;
-		}).finally(() => {
-			this.#pending.delete(task.id);
-		});
-	}
-	abortAll() {
-		for (const task of this.#pending.values()) task.abort();
-		this.#pending.clear();
-	}
-};
-/**
-* Runs tasks one at a time in submission order.
-*
-* Each schedule() call returns a Promise that resolves or rejects with the
-* task's result when it is eventually executed. Tasks wait in queue until the
-* prior task completes.
-*
-* Serialization is achieved by chaining each task's run() onto the tail of a
-* shared promise chain — no explicit queue or drain loop needed.
-*
-* abortAll() aborts all pending (not yet started) tasks and the currently
-* in-flight task. Pending tasks still run briefly but receive an aborted
-* signal and are expected to exit early.
-*/
-var SerialRunner = class {
-	#chain = Promise.resolve();
-	#pending = /* @__PURE__ */ new Set();
-	#current = null;
-	schedule(task) {
-		const t = task;
-		this.#pending.add(t);
-		const result = this.#chain.then(() => {
-			this.#pending.delete(t);
-			this.#current = t;
-			return task.run();
-		}).finally(() => {
-			this.#current = null;
-		});
-		this.#chain = result.then(() => {}, () => {});
-		return result;
-	}
-	abortAll() {
-		for (const task of this.#pending) task.abort();
-		this.#pending.clear();
-		this.#current?.abort();
-	}
-	destroy() {
-		this.abortAll();
-	}
-};
-
-//#endregion
-//#region src/core/features/resolve-track.ts
-function canResolve(state, config) {
-	const track = getSelectedTrack(state, config.type);
-	if (!track) return false;
-	return !isResolvedTrack(track);
-}
-/**
-* Determines if track resolution conditions are met.
-*
-* Currently always returns true - conditions are checked by canResolveTrack()
-* and resolving flag. Kept as placeholder for future conditional logic.
-*
-* @param state - Current track resolution state
-* @param event - Current action/event
-* @returns true (conditions checked elsewhere)
-*/
-function shouldResolve(_state, _event) {
-	return true;
-}
-/**
-* Updates a track within a presentation (immutably).
-* Generic - works for video, audio, or text tracks.
-*/
-function updateTrackInPresentation(presentation, resolvedTrack) {
-	const trackId = resolvedTrack.id;
-	return {
-		...presentation,
-		selectionSets: presentation.selectionSets.map((selectionSet) => ({
-			...selectionSet,
-			switchingSets: selectionSet.switchingSets.map((switchingSet) => ({
-				...switchingSet,
-				tracks: switchingSet.tracks.map((track) => track.id === trackId ? resolvedTrack : track)
-			}))
-		}))
-	};
-}
-/**
-* Resolves unresolved tracks using reactive composition.
-*
-* The subscribe closure is pure scheduling logic: it checks conditions and
-* creates a Task for the selected track when appropriate. The ConcurrentRunner
-* handles all concurrency concerns — deduplication, parallel execution, and
-* cleanup.
-*
-* Generic version that works for video, audio, or text tracks based on config.
-* Type parameter T is inferred from config.type (use 'as const' for inference).
-*/
-function resolveTrack({ state, events }, config) {
-	const runner = new ConcurrentRunner();
-	const cleanup = combineLatest([state, events]).subscribe(([currentState, event]) => {
-		if (!canResolve(currentState, config) || !shouldResolve(currentState, event)) return;
-		const track = getSelectedTrack(currentState, config.type);
-		if (!track) return;
-		const resolvedTrack = track;
-		runner.schedule(new Task(async (signal) => {
-			const mediaTrack = parseMediaPlaylist(await getResponseText(await fetchResolvable(resolvedTrack, { signal })), resolvedTrack);
-			const latestPresentation = state.current.presentation;
-			const updatedPresentation = updateTrackInPresentation(latestPresentation, mediaTrack);
-			state.patch({ presentation: updatedPresentation });
-		}, { id: track.id }));
-	});
-	return () => {
-		runner.abortAll();
-		cleanup();
-	};
-}
-
-//#endregion
-//#region src/core/features/select-tracks.ts
-/**
-* Pick text track to activate.
-*
-* Selection priority (if enabled):
-* 1. User preference (preferredSubtitleLanguage)
-* 2. DEFAULT track (if enableDefaultTrack is true and track has DEFAULT=YES + AUTOSELECT=YES)
-* 3. No auto-selection (user opt-in)
-*
-* By default, FORCED tracks are excluded per Apple's HLS spec.
-*
-* @param presentation - Presentation with text tracks
-* @param config - Selection configuration
-* @returns Track ID or undefined (no auto-selection)
-*/
-function pickTextTrack(presentation, config) {
-	const textSet = presentation.selectionSets.find((set) => set.type === "text");
-	if (!textSet?.switchingSets?.[0]?.tracks.length) return void 0;
-	const tracks = textSet.switchingSets[0].tracks;
-	const availableTracks = config.includeForcedTracks ? tracks : tracks.filter((track) => !track.forced);
-	if (availableTracks.length === 0) return void 0;
-	const { preferredSubtitleLanguage, enableDefaultTrack = false } = config;
-	if (preferredSubtitleLanguage) {
-		const languageMatch = availableTracks.find((track) => track.language === preferredSubtitleLanguage);
-		if (languageMatch) return languageMatch.id;
-	}
-	if (enableDefaultTrack) {
-		const defaultTrack = availableTracks.find((track) => track.default === true);
-		if (defaultTrack) return defaultTrack.id;
-	}
-}
-/**
-* Check if we can select a track of the given type.
-*
-* Returns true when:
-* - Presentation exists
-* - Has tracks of the specified type
-*
-* Generic over track type - works for video, audio, or text.
-*/
-function canSelectTrack(state, config) {
-	return !!state?.presentation?.selectionSets?.find(({ type }) => type === config.type)?.switchingSets?.[0]?.tracks.length;
-}
-/**
-* Check if we should select a track of the given type.
-*
-* Returns true when:
-* - Track of this type is not already selected
-*
-* Generic over track type - works for video, audio, or text.
-*
-* @TODO figure out reactive model for ABR cases - right now we're only selecting
-* if we have nothing selected (CJP)
-*/
-function shouldSelectTrack(state, config) {
-	return !state[SelectedTrackIdKeyByType[config.type]];
-}
-/**
-* Select video track orchestration.
-*
-* Selects video track when:
-* - Presentation exists
-* - No video track is selected yet
-*
-* Uses bandwidth-based quality selection algorithm.
-*
-* @example
-* const cleanup = selectVideoTrack(
-*   { state, owners, events },
-*   { initialBandwidth: 2_000_000 }
-* );
-*/
-function selectVideoTrack({ state }, config = { type: "video" }) {
-	let selecting = false;
-	return state.subscribe(async (currentState) => {
-		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config) || selecting) return;
-		try {
-			selecting = true;
-			const selectedTrackId = currentState.presentation?.selectionSets.find(({ type }) => type === config.type)?.switchingSets[0]?.tracks[0]?.id;
-			if (selectedTrackId) {
-				const selectedTrackKey = SelectedTrackIdKeyByType[config.type];
-				state.patch({ [selectedTrackKey]: selectedTrackId });
-			}
-		} finally {
-			selecting = false;
-		}
-	});
-}
-/**
-* Select audio track orchestration.
-*
-* Selects audio track when:
-* - Presentation exists
-* - No audio track is selected yet
-*
-* Uses language and preference-based selection.
-*
-* @example
-* const cleanup = selectAudioTrack(
-*   { state, owners, events },
-*   { preferredAudioLanguage: 'en' }
-* );
-*/
-function selectAudioTrack({ state }, config = { type: "audio" }) {
-	let selecting = false;
-	return state.subscribe(async (currentState) => {
-		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config) || selecting) return;
-		try {
-			selecting = true;
-			const selectedTrackId = currentState.presentation?.selectionSets.find(({ type }) => type === "audio")?.switchingSets[0]?.tracks[0]?.id;
-			if (selectedTrackId) state.patch({ selectedAudioTrackId: selectedTrackId });
-		} finally {
-			selecting = false;
-		}
-	});
-}
-/**
-* Select text track orchestration.
-*
-* Selects text track when:
-* - Presentation exists
-* - No text track is selected yet
-*
-* Note: Currently does not auto-select (user opt-in).
-*
-* @example
-* const cleanup = selectTextTrack({ state, owners, events }, {});
-*/
-function selectTextTrack({ state }, config = { type: "text" }) {
-	let selecting = false;
-	return state.subscribe(async (currentState) => {
-		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config) || selecting) return;
-		try {
-			selecting = true;
-			const selectedTextTrackId = pickTextTrack(currentState.presentation, config);
-			if (selectedTextTrackId) state.patch({ selectedTextTrackId });
-		} finally {
-			selecting = false;
-		}
-	});
-}
-
-//#endregion
-//#region src/dom/features/end-of-stream.ts
-/**
-* Check if the last segment of a track has been appended to a SourceBuffer.
-*
-* Checks by segment ID rather than a pipeline flag, so it is robust across
-* quality switches (different tracks have different segment IDs) and
-* back-buffer flushes (flushed segment IDs are removed from the model).
-*/
-function isLastSegmentAppended(segments, actor) {
-	if (segments.length === 0) return true;
-	const lastSeg = segments[segments.length - 1];
-	if (!lastSeg) return false;
-	return actor?.snapshot.context.segments.some((s) => s.id === lastSeg.id && !s.partial) ?? false;
-}
-/**
-* Check if the last segment has been appended for each selected track.
-*
-* Handles video-only, audio-only, and video+audio scenarios.
-* A track with no segments (e.g. unresolved) is considered not ready.
-*/
-function hasLastSegmentLoaded(state, owners) {
-	const videoTrack = state.selectedVideoTrackId ? getSelectedTrack(state, "video") : void 0;
-	const audioTrack = state.selectedAudioTrackId ? getSelectedTrack(state, "audio") : void 0;
-	if (videoTrack && !isResolvedTrack(videoTrack)) return false;
-	if (audioTrack && !isResolvedTrack(audioTrack)) return false;
-	if (videoTrack && isResolvedTrack(videoTrack)) {
-		if (!isLastSegmentAppended(videoTrack.segments, owners.videoBufferActor)) return false;
-	}
-	if (audioTrack && isResolvedTrack(audioTrack)) {
-		if (!isLastSegmentAppended(audioTrack.segments, owners.audioBufferActor)) return false;
-	}
-	return true;
-}
-/**
-* Check if we can call endOfStream.
-*/
-function canEndStream(state, owners) {
-	return !!(owners.mediaSource && state.presentation);
-}
-/**
-* Check if we should call endOfStream.
-*/
-function shouldEndStream(state, owners) {
-	if (!canEndStream(state, owners)) return false;
-	const { mediaSource, mediaElement } = owners;
-	if (mediaSource.readyState !== "open") return false;
-	if (mediaElement && mediaElement.readyState < HTMLMediaElement.HAVE_METADATA) return false;
-	const hasVideoTrack = !!state.selectedVideoTrackId;
-	const hasAudioTrack = !!state.selectedAudioTrackId;
-	if (hasVideoTrack && !owners.videoBuffer) return false;
-	if (hasAudioTrack && !owners.audioBuffer) return false;
-	if (owners.videoBufferActor?.snapshot.status === "updating") return false;
-	if (owners.audioBufferActor?.snapshot.status === "updating") return false;
-	if (!hasLastSegmentLoaded(state, owners)) return false;
-	if (mediaElement) {
-		const videoTrack = hasVideoTrack ? getSelectedTrack(state, "video") : void 0;
-		const audioTrack = hasAudioTrack ? getSelectedTrack(state, "audio") : void 0;
-		const refTrack = videoTrack && isResolvedTrack(videoTrack) ? videoTrack : audioTrack && isResolvedTrack(audioTrack) ? audioTrack : void 0;
-		if (refTrack && refTrack.segments.length > 0) {
-			const lastSeg = refTrack.segments[refTrack.segments.length - 1];
-			if (mediaElement.currentTime < lastSeg.startTime) return false;
-		}
-	}
-	return true;
-}
-/**
-* Wait for all currently-updating SourceBufferActors to finish.
-* Uses actor status rather than raw SourceBuffer.updating so the wait is
-* aligned with the same abstraction that owns all buffer operations.
-*/
-function waitForSourceBuffersReady$1(owners) {
-	const updatingActors = [owners.videoBufferActor, owners.audioBufferActor].filter((actor) => actor !== void 0 && actor.snapshot.status === "updating");
-	if (updatingActors.length === 0) return Promise.resolve();
-	return Promise.all(updatingActors.map((actor) => new Promise((resolve) => {
-		const unsub = actor.subscribe((snapshot) => {
-			if (snapshot.status !== "updating") {
-				unsub();
-				resolve();
-			}
-		});
-	}))).then(() => void 0);
-}
-/**
-* Get the highest buffered end time across all active SourceBuffers.
-* Used to set the final duration from actual container timestamps rather
-* than playlist metadata, which handles both shorter and longer cases.
-*/
-function getMaxBufferedEnd$1(owners) {
-	let max = 0;
-	for (const buf of [owners.videoBuffer, owners.audioBuffer]) if (buf && buf.buffered.length > 0) {
-		const end = buf.buffered.end(buf.buffered.length - 1);
-		if (end > max) max = end;
-	}
-	return max;
-}
-/**
-* End of stream task (module-level, pure).
-* Sets the final duration from actual buffered end time, then calls endOfStream().
-*/
-const endOfStreamTask = async ({ currentOwners }, _context) => {
-	const { mediaSource } = currentOwners;
-	if (mediaSource.readyState === "ended") return;
-	await waitForSourceBuffersReady$1(currentOwners);
-	if (mediaSource.readyState !== "open") return;
-	const bufferedEnd = getMaxBufferedEnd$1(currentOwners);
-	if (bufferedEnd > 0) mediaSource.duration = bufferedEnd;
-	mediaSource.endOfStream();
-	await new Promise((resolve) => requestAnimationFrame(resolve));
-};
-/**
-* Call endOfStream when the last segment has been appended.
-* This signals to the browser that the stream is complete.
-*
-* Per the MSE spec, appendBuffer() remains valid after endOfStream() —
-* seeks that require re-appending earlier segments will still work.
-* What becomes blocked is calling endOfStream() again, addSourceBuffer(),
-* and MediaSource.duration updates.
-*/
-function endOfStream({ state, owners }) {
-	let hasEnded = false;
-	let destroyed = false;
-	const activeActorUnsubs = [];
-	const runEvaluate = async () => {
-		if (destroyed) return;
-		const currentState = state.current;
-		const currentOwners = owners.current;
-		if (hasEnded) {
-			if (currentOwners.mediaSource?.readyState !== "open") return;
-			hasEnded = false;
-		}
-		if (!shouldEndStream(currentState, currentOwners)) return;
-		hasEnded = true;
-		try {
-			await endOfStreamTask({ currentOwners }, {});
-		} catch (error) {
-			console.error("Failed to call endOfStream:", error);
-		}
-	};
-	const cleanupOwners = owners.subscribe((currentOwners) => {
-		activeActorUnsubs.forEach((u) => u());
-		activeActorUnsubs.length = 0;
-		for (const actor of [currentOwners.videoBufferActor, currentOwners.audioBufferActor]) {
-			if (!actor) continue;
-			let isFirst = true;
-			activeActorUnsubs.push(actor.subscribe(() => {
-				if (isFirst) {
-					isFirst = false;
-					return;
-				}
-				runEvaluate();
-			}));
-		}
-	});
-	const cleanupCombineLatest = combineLatest([state, owners]).subscribe(async () => runEvaluate());
-	return () => {
-		destroyed = true;
-		activeActorUnsubs.forEach((u) => u());
-		cleanupOwners();
-		cleanupCombineLatest();
-	};
-}
-
-//#endregion
-//#region src/dom/features/setup-mediasource.ts
-/**
-* Check if we have the minimum requirements to create MediaSource.
-*/
-function canSetup(state, owners) {
-	return !isNil(owners.mediaElement) && !isNil(state.presentation?.url);
-}
-/**
-* Check if we should proceed with MediaSource creation.
-* Placeholder for future conditions (e.g., checking if already created).
-*/
-function shouldSetup(_state, owners) {
-	return isNil(owners.mediaSource);
-}
-/**
-* Setup MediaSource orchestration.
-*
-* Creates and attaches MediaSource when:
-* - mediaElement exists in owners
-* - presentation.url exists in state
-*
-* Updates owners.mediaSource after successful setup.
-*/
-function setupMediaSource({ state, owners }) {
-	let settingUp = false;
-	let abortController = null;
-	const unsubscribe = combineLatest([state, owners]).subscribe(async ([currentState, currentOwners]) => {
-		if (!canSetup(currentState, currentOwners) || !shouldSetup(currentState, currentOwners) || settingUp) return;
-		try {
-			settingUp = true;
-			abortController = new AbortController();
-			const mediaSource = createMediaSource({ preferManaged: true });
-			attachMediaSource(mediaSource, currentOwners.mediaElement);
-			await waitForSourceOpen(mediaSource, abortController.signal);
-			owners.patch({ mediaSource });
-		} catch (error) {
-			if (error instanceof DOMException && error.name === "AbortError") return;
-			throw error;
-		} finally {
-			settingUp = false;
-		}
-	});
-	return () => {
-		abortController?.abort();
-		unsubscribe();
-	};
-}
-
-//#endregion
-//#region src/dom/media/source-buffer-actor.ts
-/**
-* Thrown when a message is sent to the actor in a state that does not
-* accept messages (currently: 'updating').
-*/
-var SourceBufferActorError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "SourceBufferActorError";
-	}
-};
-function snapshotBuffered(buffered) {
-	const ranges = [];
-	for (let i = 0; i < buffered.length; i++) ranges.push({
-		start: buffered.start(i),
-		end: buffered.end(i)
-	});
-	return ranges;
-}
-function appendInitTask(message, { signal, getCtx, sourceBuffer }) {
-	return new Task(async (taskSignal) => {
-		const ctx = getCtx();
-		if (taskSignal.aborted) return ctx;
-		await appendSegment(sourceBuffer, message.data);
-		return {
-			...ctx,
-			initTrackId: message.meta.trackId
-		};
-	}, { signal });
-}
-function appendSegmentTask(message, { signal, getCtx, sourceBuffer, onPartialContext }) {
-	return new Task(async (taskSignal) => {
-		const ctx = getCtx();
-		if (taskSignal.aborted) return ctx;
-		const { meta } = message;
-		const EPSILON = 1e-4;
-		const filtered = ctx.segments.filter((s) => Math.abs(s.startTime - meta.startTime) >= EPSILON);
-		if (!(message.data instanceof ArrayBuffer)) onPartialContext({
-			...ctx,
-			segments: [...filtered, {
-				id: meta.id,
-				startTime: meta.startTime,
-				duration: meta.duration,
-				trackId: meta.trackId,
-				...meta.trackBandwidth !== void 0 && { trackBandwidth: meta.trackBandwidth },
-				partial: true
-			}],
-			bufferedRanges: ctx.bufferedRanges
-		});
-		await appendSegment(sourceBuffer, message.data, taskSignal);
-		return {
-			...ctx,
-			segments: [...filtered, {
-				id: meta.id,
-				startTime: meta.startTime,
-				duration: meta.duration,
-				trackId: meta.trackId,
-				...meta.trackBandwidth !== void 0 && { trackBandwidth: meta.trackBandwidth }
-			}],
-			bufferedRanges: snapshotBuffered(sourceBuffer.buffered)
-		};
-	}, { signal });
-}
-function removeTask(message, { signal, getCtx, sourceBuffer }) {
-	return new Task(async (taskSignal) => {
-		const ctx = getCtx();
-		if (taskSignal.aborted) return ctx;
-		await flushBuffer(sourceBuffer, message.start, message.end);
-		const bufferedRanges = snapshotBuffered(sourceBuffer.buffered);
-		const filtered = ctx.segments.filter((s) => {
-			const midpoint = s.startTime + s.duration / 2;
-			return bufferedRanges.some((r) => midpoint >= r.start && midpoint < r.end);
-		});
-		return {
-			...ctx,
-			segments: filtered,
-			bufferedRanges
-		};
-	}, { signal });
-}
-const messageTaskFactories = {
-	"append-init": appendInitTask,
-	"append-segment": appendSegmentTask,
-	remove: removeTask
-};
-function messageToTask(message, options) {
-	const factory = messageTaskFactories[message.type];
-	return factory(message, options);
-}
-function createSourceBufferActor(sourceBuffer, initialContext) {
-	const state = createState({
-		status: "idle",
-		context: {
-			segments: [],
-			bufferedRanges: [],
-			initTrackId: void 0,
-			...initialContext
-		}
-	});
-	const runner = new SerialRunner();
-	function applyResult(newContext) {
-		const status = state.current.status === "destroyed" ? "destroyed" : "idle";
-		state.patch({
-			status,
-			context: newContext
-		});
-		state.flush();
-	}
-	function handleError(e) {
-		const status = state.current.status === "destroyed" ? "destroyed" : "idle";
-		state.patch({ status });
-		state.flush();
-		throw e;
-	}
-	return {
-		get snapshot() {
-			return state.current;
-		},
-		subscribe(listener) {
-			return state.subscribe(listener);
-		},
-		send(message, signal) {
-			if (state.current.status !== "idle") return Promise.reject(new SourceBufferActorError(`send() called while actor is ${state.current.status}`));
-			state.patch({ status: "updating" });
-			const onPartialContext = (ctx) => {
-				state.patch({
-					status: "updating",
-					context: ctx
-				});
-				state.flush();
-			};
-			const task = messageToTask(message, {
-				signal,
-				getCtx: () => state.current.context,
-				sourceBuffer,
-				onPartialContext
-			});
-			return runner.schedule(task).then(applyResult).catch(handleError);
-		},
-		batch(messages, signal) {
-			if (state.current.status !== "idle") return Promise.reject(new SourceBufferActorError(`batch() called while actor is ${state.current.status}`));
-			if (messages.length === 0) return Promise.resolve();
-			state.patch({ status: "updating" });
-			let workingCtx = state.current.context;
-			const onPartialContext = (ctx) => {
-				state.patch({
-					status: "updating",
-					context: ctx
-				});
-				state.flush();
-			};
-			for (const message of messages.slice(0, -1)) {
-				const task = messageToTask(message, {
-					signal,
-					getCtx: () => workingCtx,
-					sourceBuffer,
-					onPartialContext
-				});
-				runner.schedule(task).then((newCtx) => {
-					workingCtx = newCtx;
-				});
-			}
-			const lastTask = messageToTask(messages[messages.length - 1], {
-				signal,
-				getCtx: () => workingCtx,
-				sourceBuffer,
-				onPartialContext
-			});
-			return runner.schedule(lastTask).then(applyResult).catch(handleError);
-		},
-		destroy() {
-			state.patch({ status: "destroyed" });
-			state.flush();
-			runner.destroy();
-		}
-	};
-}
-
-//#endregion
-//#region src/dom/features/setup-sourcebuffer.ts
-/**
-* Build MIME codec string from track metadata.
-*
-* @param track - Resolved track with mimeType and codecs
-* @returns MIME codec string (e.g., 'video/mp4; codecs="avc1.42E01E,mp4a.40.2"')
-*
-* @example
-* buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })
-* // => 'video/mp4; codecs="avc1.42E01E"'
-*/
-function buildMimeCodec(track) {
-	const codecString = track.codecs?.join(",") ?? "";
-	return `${track.mimeType}; codecs="${codecString}"`;
-}
-/**
-* Setup all needed SourceBuffers as a single coordinated operation.
-*
-* Waits until ALL selected tracks (video and/or audio) are resolved with
-* codecs, then creates every SourceBuffer in one synchronous block before
-* patching owners. This guarantees that downstream consumers (e.g.
-* loadSegments) never see a partial set of SourceBuffers — preventing the
-* Firefox bug where appending to a video SourceBuffer before the audio
-* SourceBuffer exists causes mozHasAudio to be permanently false.
-*
-* Handles video-only, audio-only, and combined presentations correctly:
-* only the tracks that are actually selected are waited on and created.
-*
-* @example
-* const cleanup = setupSourceBuffers({ state, owners });
-*/
-function setupSourceBuffers({ state, owners }) {
-	let setupDone = false;
-	return combineLatest([state, owners]).subscribe(async ([currentState, currentOwners]) => {
-		if (setupDone) return;
-		if (!currentOwners.mediaSource) return;
-		const videoSelected = !!currentState.selectedVideoTrackId;
-		const audioSelected = !!currentState.selectedAudioTrackId;
-		if (!videoSelected && !audioSelected) return;
-		const videoTrack = videoSelected ? getSelectedTrack(currentState, "video") : null;
-		const audioTrack = audioSelected ? getSelectedTrack(currentState, "audio") : null;
-		if (videoSelected && (!videoTrack || !isResolvedTrack(videoTrack) || !videoTrack.codecs?.length)) return;
-		if (audioSelected && (!audioTrack || !isResolvedTrack(audioTrack) || !audioTrack.codecs?.length)) return;
-		setupDone = true;
-		const patch = {};
-		if (videoSelected && videoTrack && isResolvedTrack(videoTrack)) {
-			const buffer = createSourceBuffer(currentOwners.mediaSource, buildMimeCodec(videoTrack));
-			patch.videoBuffer = buffer;
-			patch.videoBufferActor = createSourceBufferActor(buffer);
-		}
-		if (audioSelected && audioTrack && isResolvedTrack(audioTrack)) {
-			const buffer = createSourceBuffer(currentOwners.mediaSource, buildMimeCodec(audioTrack));
-			patch.audioBuffer = buffer;
-			patch.audioBufferActor = createSourceBufferActor(buffer);
-		}
-		owners.patch(patch);
-		await new Promise((resolve) => requestAnimationFrame(resolve));
-	});
-}
-
-//#endregion
-//#region src/dom/features/setup-text-tracks.ts
-/**
-* Get all text tracks from presentation.
-*/
-function getTextTracks(presentation) {
-	if (!presentation?.selectionSets) return [];
-	const textSet = presentation.selectionSets.find((set) => set.type === "text");
-	if (!textSet?.switchingSets?.[0]?.tracks) return [];
-	return textSet.switchingSets[0].tracks;
-}
-/**
-* Check if we can setup text tracks.
-*
-* Requires:
-* - mediaElement exists
-* - presentation has text tracks to setup
-*/
-function canSetupTextTracks(state, owners) {
-	return !!owners.mediaElement && !!getTextTracks(state.presentation).length;
-}
-/**
-* Check if we should setup text tracks (not already set up).
-*/
-function shouldSetupTextTracks(owners) {
-	return !owners.textTracks;
-}
-/**
-* Create a track element for a text track.
-*
-* Note: We use DOM <track> elements instead of the TextTrack JS API
-* because there's no way to remove TextTracks added via addTextTrack().
-*/
-function createTrackElement(track) {
-	const trackElement = document.createElement("track");
-	trackElement.id = track.id;
-	trackElement.kind = track.kind;
-	trackElement.label = track.label;
-	if (track.language) trackElement.srclang = track.language;
-	if (track.default) trackElement.default = true;
-	trackElement.src = track.url;
-	return trackElement;
-}
-/**
-* Setup text tracks orchestration.
-*
-* Triggers when:
-* - mediaElement exists
-* - presentation is resolved (has text tracks)
-*
-* Creates <track> elements for all text tracks and adds them as children
-* to the media element. This allows the browser's native text track rendering.
-*
-* Note: Uses DOM track elements instead of TextTrack API because tracks
-* added via addTextTrack() cannot be removed.
-*
-* @example
-* const cleanup = setupTextTracks({ state, owners });
-*/
-function setupTextTracks({ state, owners }) {
-	let hasSetup = false;
-	let createdTracks = [];
-	const unsubscribe = combineLatest([state, owners]).subscribe(([s, o]) => {
-		if (hasSetup) return;
-		if (!canSetupTextTracks(s, o) || !shouldSetupTextTracks(o)) return;
-		hasSetup = true;
-		const textTracks = getTextTracks(s.presentation);
-		if (textTracks.length === 0) return;
-		const trackMap = /* @__PURE__ */ new Map();
-		for (const track of textTracks) {
-			const trackElement = createTrackElement(track);
-			o.mediaElement.appendChild(trackElement);
-			trackMap.set(track.id, trackElement);
-			createdTracks.push(trackElement);
-		}
-		owners.patch({ textTracks: trackMap });
-	});
-	return () => {
-		for (const trackElement of createdTracks) trackElement.remove();
-		createdTracks = [];
-		unsubscribe();
-	};
-}
-
-//#endregion
-//#region src/dom/features/sync-selected-text-track-from-dom.ts
-/**
-* Sync selectedTextTrackId from DOM text track mode changes.
-*
-* Listens to the `change` event on `media.textTracks` and updates
-* `selectedTextTrackId` when external code (e.g. the captions button via
-* `toggleSubtitles()`) changes a subtitle/caption track mode to 'showing'.
-*
-* This bridges the core store's `toggleSubtitles()` with SPF's reactive text
-* track pipeline (`syncTextTrackModes`, `loadTextTrackCues`). Without this
-* bridge, direct DOM mode changes would be immediately overridden by
-* `syncTextTrackModes` on the next SPF state update.
-*
-* When a subtitle/caption track's mode is 'showing', its DOM `id` — which
-* matches the SPF track ID set by `setupTextTracks` — is written to
-* `selectedTextTrackId`. When no subtitle/caption track is 'showing',
-* `selectedTextTrackId` is cleared along with the deselected track's
-* `textBufferState` entry — setting mode to 'disabled' clears native cues from
-* the track element, so the buffer must be reset to re-fetch cues on re-enable.
-*
-* @example
-* const cleanup = syncSelectedTextTrackFromDom({ state, owners });
-*/
-function syncSelectedTextTrackFromDom({ state, owners }) {
-	let lastMediaElement;
-	let removeListener = null;
-	const unsubscribe = owners.subscribe((currentOwners) => {
-		const { mediaElement } = currentOwners;
-		if (mediaElement === lastMediaElement) return;
-		removeListener?.();
-		removeListener = null;
-		lastMediaElement = mediaElement;
-		if (!mediaElement) return;
-		const sync = () => {
-			const newId = Array.from(mediaElement.textTracks).find((t) => t.mode === "showing" && (t.kind === "subtitles" || t.kind === "captions"))?.id || void 0;
-			const current = state.current;
-			if (current.selectedTextTrackId === newId) return;
-			if (newId) state.patch({ selectedTextTrackId: newId });
-			else {
-				const prevId = current.selectedTextTrackId;
-				if (prevId && current.textBufferState?.[prevId]) {
-					const next = { ...current.textBufferState };
-					delete next[prevId];
-					state.patch({
-						selectedTextTrackId: void 0,
-						textBufferState: next
-					});
-				} else state.patch({ selectedTextTrackId: void 0 });
-			}
-		};
-		removeListener = listen(mediaElement.textTracks, "change", sync);
-	});
-	return () => {
-		removeListener?.();
-		unsubscribe();
-	};
-}
-
-//#endregion
-//#region src/dom/features/sync-text-track-modes.ts
-/**
-* Check if we can sync text track modes.
-*
-* Requires:
-* - textTracks map exists (track elements created)
-*/
-function canSyncTextTrackModes(owners) {
-	return !!owners.textTracks && owners.textTracks.size > 0;
-}
-/**
-* Sync text track modes orchestration.
-*
-* Manages track element modes based on selectedTextTrackId:
-* - Selected track: mode = "showing"
-* - Other tracks: mode = "hidden"
-* - No selection: all tracks mode = "hidden"
-*
-* Note: Uses "hidden" instead of "disabled" for non-selected tracks
-* so they remain available in the browser's track menu.
-*
-* @example
-* const cleanup = syncTextTrackModes({ state, owners });
-*/
-function syncTextTrackModes({ state, owners }) {
-	return combineLatest([state, owners]).subscribe(([s, o]) => {
-		if (!canSyncTextTrackModes(o)) return;
-		const selectedId = s.selectedTextTrackId;
-		for (const [trackId, trackElement] of o.textTracks) if (trackId === selectedId) trackElement.track.mode = "showing";
-		else trackElement.track.mode = "hidden";
-	});
-}
-
-//#endregion
-//#region src/dom/features/update-duration.ts
-/**
-* Check if we can update MediaSource duration (have required data).
-*/
-function canUpdateDuration(state, owners) {
-	return !!(owners.mediaSource && state.presentation && hasPresentationDuration(state.presentation));
-}
-/**
-* Get the maximum buffered end time across all SourceBuffers.
-*/
-function getMaxBufferedEnd(owners) {
-	let maxEnd = 0;
-	const buffers = [owners.videoSourceBuffer, owners.audioSourceBuffer].filter((buf) => buf !== void 0);
-	for (const buffer of buffers) {
-		const { buffered } = buffer;
-		if (buffered.length > 0) {
-			const end = buffered.end(buffered.length - 1);
-			if (end > maxEnd) maxEnd = end;
-		}
-	}
-	return maxEnd;
-}
-/**
-* Check if we should update MediaSource duration (conditions met).
-*/
-function shouldUpdateDuration(state, owners) {
-	if (!canUpdateDuration(state, owners)) return false;
-	const { mediaSource } = owners;
-	const { presentation } = state;
-	if (mediaSource.readyState !== "open") return false;
-	const duration = presentation.duration;
-	if (!Number.isFinite(duration) || Number.isNaN(duration) || duration <= 0) return false;
-	return Number.isNaN(mediaSource.duration);
-}
-/**
-* Wait for all currently-updating SourceBuffers to finish.
-*
-* The MSE spec forbids setting MediaSource.duration while any attached
-* SourceBuffer has updating === true. This defers until all are idle.
-*/
-function waitForSourceBuffersReady(owners) {
-	const updating = [owners.videoSourceBuffer, owners.audioSourceBuffer].filter((buf) => buf?.updating === true);
-	if (updating.length === 0) return Promise.resolve();
-	return Promise.all(updating.map((buf) => new Promise((resolve) => buf.addEventListener("updateend", () => resolve(), { once: true })))).then(() => void 0);
-}
-/**
-* Update MediaSource duration when presentation duration becomes available.
-*/
-function updateDuration({ state, owners }) {
-	let destroyed = false;
-	const unsubscribe = combineLatest([state, owners]).subscribe(async ([currentState, currentOwners]) => {
-		if (!shouldUpdateDuration(currentState, currentOwners)) return;
-		const { mediaSource } = currentOwners;
-		await waitForSourceBuffersReady(currentOwners);
-		if (destroyed || mediaSource.readyState !== "open") return;
-		let duration = currentState.presentation.duration;
-		const maxBufferedEnd = getMaxBufferedEnd(currentOwners);
-		if (maxBufferedEnd > duration) duration = maxBufferedEnd;
-		mediaSource.duration = duration;
-	});
-	return () => {
-		destroyed = true;
-		unsubscribe();
-	};
-}
-
-//#endregion
-//#region src/dom/playback-engine/engine.ts
-/**
-* Create a POC playback engine.
-*
-* Wires together all orchestrations to create a reactive playback pipeline:
-* 1. Resolve presentation (multivariant playlist)
-* 2. Select initial video and audio tracks
-* 3. Resolve selected tracks (media playlists)
-* 4. Setup MediaSource
-* 5. Setup SourceBuffers for video and audio
-*
-* Note: This is a POC - does not yet load/append segments.
-*
-* @param config - Playback engine configuration
-* @returns Playback engine instance with state, owners, and destroy function
-*
-* @example
-* const engine = createPlaybackEngine({
-*   initialBandwidth: 2_000_000,
-*   preferredAudioLanguage: 'en',
-* });
-*
-* // Initialize by patching state and owners
-* engine.owners.patch({ mediaElement: document.querySelector('video') });
-* engine.state.patch({
-*   presentation: { url: 'https://example.com/playlist.m3u8' },
-*   preload: 'auto',
-* });
-*
-* // Inspect state
-* console.log(engine.state.current);
-*
-* // Cleanup
-* engine.destroy();
-*/
-function createPlaybackEngine(config = {}) {
-	const state = createState({ bandwidthState: {
-		fastEstimate: 0,
-		fastTotalWeight: 0,
-		slowEstimate: 0,
-		slowTotalWeight: 0,
-		bytesSampled: 0
-	} });
-	const owners = createState({});
-	const events = createEventStream();
-	const cleanups = [
-		syncPreloadAttribute(state, owners),
-		trackPlaybackInitiated({
-			state,
-			owners,
-			events
-		}),
-		resolvePresentation({
-			state,
-			events
-		}),
-		selectVideoTrack({
-			state,
-			owners,
-			events
-		}, {
-			type: "video",
-			...config.initialBandwidth !== void 0 && { initialBandwidth: config.initialBandwidth }
-		}),
-		selectAudioTrack({
-			state,
-			owners,
-			events
-		}, {
-			type: "audio",
-			...config.preferredAudioLanguage !== void 0 && { preferredAudioLanguage: config.preferredAudioLanguage }
-		}),
-		selectTextTrack({
-			state,
-			owners,
-			events
-		}, {
-			type: "text",
-			...config.preferredSubtitleLanguage !== void 0 && { preferredSubtitleLanguage: config.preferredSubtitleLanguage },
-			...config.includeForcedTracks !== void 0 && { includeForcedTracks: config.includeForcedTracks },
-			...config.enableDefaultTrack !== void 0 && { enableDefaultTrack: config.enableDefaultTrack }
-		}),
-		resolveTrack({
-			state,
-			events
-		}, { type: "video" }),
-		resolveTrack({
-			state,
-			events
-		}, { type: "audio" }),
-		resolveTrack({
-			state,
-			events
-		}, { type: "text" }),
-		calculatePresentationDuration({ state }),
-		setupMediaSource({
-			state,
-			owners
-		}),
-		updateDuration({
-			state,
-			owners
-		}),
-		setupSourceBuffers({
-			state,
-			owners
-		}),
-		trackCurrentTime({
-			state,
-			owners
-		}),
-		switchQuality({ state }),
-		loadSegments({
-			state,
-			owners
-		}, { type: "video" }),
-		loadSegments({
-			state,
-			owners
-		}, { type: "audio" }),
-		endOfStream({
-			state,
-			owners
-		}),
-		setupTextTracks({
-			state,
-			owners
-		}),
-		syncTextTrackModes({
-			state,
-			owners
-		}),
-		syncSelectedTextTrackFromDom({
-			state,
-			owners
-		}),
-		loadTextTrackCues({
-			state,
-			owners
-		})
-	];
-	events.dispatch({ type: "@@INITIALIZE@@" });
-	return {
-		state,
-		owners,
-		events,
-		destroy: () => {
-			cleanups.forEach((cleanup) => cleanup());
-			destroyVttParser();
-		}
-	};
-}
-
-//#endregion
-//#region src/dom/playback-engine/adapter.ts
-/**
-* HTMLMediaElement-compatible adapter for the SPF playback engine.
-*
-* Implements the src/play() contract per the WHATWG HTML spec so that SPF can
-* be used anywhere a media element API is expected.
-*
-* A new engine is created on every src assignment — this fully tears down all
-* state, SourceBuffers, and in-flight requests from the previous source before
-* the next one begins. The media element reference is preserved across src
-* changes and re-applied to the new engine automatically.
-*
-* @example
-* const media = new SpfMedia({ preferredAudioLanguage: 'en' });
-* media.attach(document.querySelector('video'));
-* media.src = 'https://stream.mux.com/abc123.m3u8';
-*
-* // Change source — old engine is destroyed, new one starts clean:
-* media.src = 'https://stream.mux.com/xyz456.m3u8';
-*
-* // Explicit teardown:
-* media.destroy();
-*/
-var SpfMedia = class {
-	#engine;
-	#config;
-	/** Pending loadstart listener from a deferred play() retry, if any. */
-	#loadstartListener = null;
-	constructor(config = {}) {
-		this.#config = config;
-		this.#engine = createPlaybackEngine(config);
-	}
-	get engine() {
-		return this.#engine;
-	}
-	attach(mediaElement) {
-		this.#engine.owners.patch({ mediaElement });
-	}
-	detach() {
-		this.#cancelPendingPlay();
-		this.#engine.owners.patch({ mediaElement: void 0 });
-	}
-	destroy() {
-		this.#cancelPendingPlay();
-		this.#engine.destroy();
-	}
-	get src() {
-		return this.#engine.state.current.presentation?.url ?? "";
-	}
-	set src(value) {
-		const prevMediaElement = this.#engine.owners.current.mediaElement;
-		this.#cancelPendingPlay();
-		this.#engine.destroy();
-		this.#engine = createPlaybackEngine(this.#config);
-		if (prevMediaElement) this.#engine.owners.patch({ mediaElement: prevMediaElement });
-		if (value) this.#engine.state.patch({ presentation: { url: value } });
-	}
-	play() {
-		const { mediaElement } = this.#engine.owners.current;
-		if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("SpfMedia: no media element attached"));
-		this.#engine.state.patch({ playbackInitiated: true });
-		return mediaElement.play().catch((err) => {
-			if (this.src) return new Promise((resolve, reject) => {
-				const listener = () => {
-					this.#loadstartListener = null;
-					mediaElement.play().then(resolve, reject);
-				};
-				this.#loadstartListener = listener;
-				mediaElement.addEventListener("loadstart", listener, { once: true });
-			});
-			throw err;
-		});
-	}
-	#cancelPendingPlay() {
-		if (!this.#loadstartListener) return;
-		const { mediaElement } = this.#engine.owners.current;
-		mediaElement?.removeEventListener("loadstart", this.#loadstartListener);
-		this.#loadstartListener = null;
-	}
-};
-
-//#endregion
-export { trackPlaybackInitiated as a, destroyVttParser as c, appendSegment as i, parseVttSegment as l, createPlaybackEngine as n, trackCurrentTime as o, flushBuffer as r, loadTextTrackCues as s, SpfMedia as t, loadSegments as u };
-//# sourceMappingURL=adapter-ClnRGbQf.js.map