@videojs/html 10.0.0-beta.1 → 10.0.0-beta.10

package/cdn/media/simple-hls-video.dev.js

@@ -0,0 +1,3465 @@
+import { n as isNil } from "../predicate-BG-dj_kF.js";
+import { t as listen } from "../listen-BXAYCbZA.js";
+import { t as MediaAttachMixin } from "../media-attach-mixin-ChyNp2eK.js";
+import { n as DelegateMixin, t as CustomMediaMixin } from "../proxy-dR7IDk37.js";
+
+//#region ../spf/dist/adapter-CflgYzjF.js
+/**
+* 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);
+}
+/**
+* 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));
+}
+/**
+* Resolve a potentially relative URL against a base URL using native URL API.
+*/
+function resolveUrl(url, baseUrl) {
+	return new URL(url, baseUrl).href;
+}
+/**
+* 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
+	};
+}
+/**
+* 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)}`;
+}
+/**
+* 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
+	};
+}
+/**
+* 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);
+}
+/**
+* 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);
+}
+/**
+* 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);
+}
+/**
+* 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;
+}
+/**
+* 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;
+	});
+}
+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;
+}
+/**
+* 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);
+}
+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;
+}
+/**
+* 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();
+}
+/**
+* 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);
+		}
+	};
+}
+/**
+* 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);
+			}
+		});
+	} };
+}
+/**
+* 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) => {
+		if (state.current.preload !== void 0) return;
+		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();
+	};
+}
+/**
+* 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 });
+	});
+}
+/**
+* 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);
+}
+/**
+* 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();
+		}
+	};
+}
+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();
+	};
+}
+/**
+* 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;
+}
+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();
+	};
+}
+/**
+* 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();
+	};
+}
+/**
+* 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();
+	};
+}
+/**
+* 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 try {
+		for await (const chunk of data) {
+			if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+			await appendChunk(sourceBuffer, chunk);
+		}
+	} catch (e) {
+		if (e instanceof DOMException && e.name === "AbortError" && !sourceBuffer.updating) try {
+			sourceBuffer.abort();
+		} catch {}
+		throw e;
+	}
+}
+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);
+		}
+	});
+}
+/**
+* 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);
+		}
+	});
+}
+/**
+* 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
+		} });
+	});
+}
+/**
+* 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();
+	}
+};
+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();
+	};
+}
+/**
+* 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;
+		}
+	});
+}
+/**
+* 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();
+	};
+}
+/**
+* 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();
+	};
+}
+/**
+* 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();
+		}
+	};
+}
+/**
+* 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));
+	});
+}
+/**
+* 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();
+	};
+}
+/**
+* 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();
+	};
+}
+/**
+* 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";
+	});
+}
+/**
+* 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();
+	};
+}
+/**
+* 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();
+		}
+	};
+}
+/**
+* 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;
+	#preload = "";
+	/** 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 preload() {
+		return this.#preload;
+	}
+	set preload(value) {
+		this.#preload = value;
+		if (value) this.#engine.state.patch({ preload: value });
+	}
+	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 (this.#preload) this.#engine.state.patch({ preload: this.#preload });
+		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
+//#region ../core/dist/dev/dom/media/simple-hls/index.js
+var SimpleHlsCustomMedia = class extends DelegateMixin(CustomMediaMixin(globalThis.HTMLElement ?? class {}, { tag: "video" }), SpfMedia) {};
+
+//#endregion
+//#region src/media/simple-hls-video/index.ts
+var SimpleHlsVideo = class extends MediaAttachMixin(SimpleHlsCustomMedia) {
+	static getTemplateHTML(attrs) {
+		const { src, ...rest } = attrs;
+		return super.getTemplateHTML(rest);
+	}
+	constructor() {
+		super();
+		this.attach(this.target);
+	}
+	attributeChangedCallback(attrName, oldValue, newValue) {
+		if (attrName !== "src") super.attributeChangedCallback(attrName, oldValue, newValue);
+		if (attrName === "src" && oldValue !== newValue) this.src = newValue ?? "";
+		if (attrName === "preload" && oldValue !== newValue) this.preload = newValue ?? "";
+	}
+};
+
+//#endregion
+//#region src/define/media/simple-hls-video.ts
+var SimpleHlsVideoElement = class extends SimpleHlsVideo {
+	static {
+		this.tagName = "simple-hls-video";
+	}
+};
+customElements.define(SimpleHlsVideoElement.tagName, SimpleHlsVideoElement);
+
+//#endregion
+//# sourceMappingURL=simple-hls-video.dev.js.map