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

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

@@ -1,9 +1,11 @@
 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";
+import "../context-Be8C5kVd.js";
+import { t as listen } from "../listen-YSH3Jfyk.js";
+import { t as DelegateMixin } from "../delegate-CzAcT1xm.js";
+import { t as MediaAttachMixin } from "../media-attach-mixin-U_KQB_9O.js";
+import { t as CustomMediaMixin } from "../custom-media-element-moFa3UZp.js";
 
-//#region ../spf/dist/adapter-CflgYzjF.js
+//#region ../spf/dist/dev/core/state/create-state.js
 /**
 * Reactive state container with selectors, custom equality, and batched updates.
 *
@@ -61,11 +63,11 @@ var StateContainer = class {
 	}
 	subscribe(selectorOrListener, maybeListener, options) {
 		if (maybeListener === void 0) {
-			const listener$1 = selectorOrListener;
-			this.#listeners.add(listener$1);
-			listener$1(this.current);
+			const listener = selectorOrListener;
+			this.#listeners.add(listener);
+			listener(this.current);
 			return () => {
-				this.#listeners.delete(listener$1);
+				this.#listeners.delete(listener);
 			};
 		}
 		const selector = selectorOrListener;
@@ -142,6 +144,432 @@ var StateContainer = class {
 function createState(initial, config) {
 	return new StateContainer(initial, config);
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/abr/ewma.js
+/**
+* Exponentially Weighted Moving Average (EWMA)
+*
+* Pure functional implementation of EWMA calculations.
+* Based on Shaka Player's EWMA algorithm.
+*/
+/**
+* Calculate alpha (decay factor) from half-life.
+*
+* Alpha determines how quickly old data "expires":
+* - alpha close to 1 = slow decay (long memory)
+* - alpha close to 0 = fast decay (short memory)
+*
+* @param halfLife - The quantity of prior samples (by weight) that make up
+*   half of the new estimate. Must be positive.
+* @returns Alpha value between 0 and 1
+*
+* @example
+* const alpha = calculateAlpha(2); // ≈ 0.7071 for 2-second half-life
+*/
+function calculateAlpha(halfLife) {
+	return Math.exp(Math.log(.5) / halfLife);
+}
+/**
+* Calculate exponentially weighted moving average.
+*
+* Updates an estimate by blending a new value with the previous estimate,
+* weighted by the sample duration. Longer samples have more influence.
+*
+* @param prevEstimate - Previous EWMA estimate
+* @param value - New sample value to incorporate
+* @param weight - Sample weight (typically duration in seconds)
+* @param halfLife - Half-life for decay (typically 2-5 seconds)
+* @returns Updated EWMA estimate
+*
+* @example
+* let estimate = 0;
+* estimate = calculateEwma(estimate, 1_000_000, 1, 2); // First sample
+* estimate = calculateEwma(estimate, 2_000_000, 1, 2); // Second sample
+*/
+function calculateEwma(prevEstimate, value, weight, halfLife) {
+	const adjAlpha = calculateAlpha(halfLife) ** weight;
+	return value * (1 - adjAlpha) + adjAlpha * prevEstimate;
+}
+/**
+* Apply zero-factor correction to EWMA estimate.
+*
+* The zero-factor correction compensates for bias when starting from zero.
+* Without this correction, early estimates would be artificially low.
+*
+* As totalWeight increases, the correction factor approaches 1, meaning
+* the estimate becomes more reliable and needs less correction.
+*
+* @param estimate - Raw EWMA estimate (uncorrected)
+* @param totalWeight - Accumulated weight from all samples
+* @param halfLife - Half-life used in EWMA calculation
+* @returns Corrected estimate, or 0 if totalWeight is 0
+*
+* @example
+* const raw = calculateEwma(0, 1_000_000, 1, 2);
+* const corrected = applyZeroFactor(raw, 1, 2); // ≈ 1_000_000
+*/
+function applyZeroFactor(estimate, totalWeight, halfLife) {
+	if (totalWeight === 0) return 0;
+	return estimate / (1 - calculateAlpha(halfLife) ** totalWeight);
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/abr/bandwidth-estimator.js
+/**
+* Dual EWMA Bandwidth Estimator
+*
+* Estimates available bandwidth using two EWMA calculations with different
+* half-lives, taking the minimum of both. This approach (from Shaka Player):
+*
+* - **Fast EWMA** (2s half-life): Reacts quickly to bandwidth drops
+* - **Slow EWMA** (5s half-life): Provides stability during fluctuations
+* - **min(fast, slow)**: Adapts down quickly, up slowly
+*
+* This naturally provides asymmetric behavior needed for good QoE:
+* avoiding stalls (quick downgrade) while preventing oscillation (slow upgrade).
+*/
+/**
+* Default bandwidth estimator configuration.
+*
+* Values match Shaka Player defaults based on experimentation.
+*/
+const DEFAULT_BANDWIDTH_CONFIG = {
+	fastHalfLife: 2,
+	slowHalfLife: 5,
+	minTotalBytes: 128e3,
+	minBytes: 16e3,
+	minDuration: 5
+};
+/**
+* Add a bandwidth sample from a segment download.
+*
+* Samples are filtered based on:
+* - Minimum bytes (filters TTFB-dominated small segments)
+* - Minimum duration (filters cached responses)
+*
+* Valid samples update both fast and slow EWMA estimates.
+*
+* @param state - Current estimator state
+* @param durationMs - Download duration in milliseconds
+* @param numBytes - Number of bytes downloaded
+* @param config - Optional estimator configuration (uses defaults if not provided)
+* @returns New estimator state with sample incorporated (or unchanged if filtered)
+*
+* @example
+* let state = { fastEstimate: 0, fastTotalWeight: 0, ... };
+* // Sample: 1MB in 1 second
+* state = sampleBandwidth(state, 1000, 1_000_000);
+*/
+function sampleBandwidth(state, durationMs, numBytes, config = DEFAULT_BANDWIDTH_CONFIG) {
+	const updatedBytesSampled = state.bytesSampled + numBytes;
+	if (numBytes < config.minBytes) return {
+		...state,
+		bytesSampled: updatedBytesSampled
+	};
+	if (durationMs < config.minDuration) return {
+		...state,
+		bytesSampled: updatedBytesSampled
+	};
+	const bandwidth = 8e3 * numBytes / durationMs;
+	const weight = durationMs / 1e3;
+	return {
+		fastEstimate: calculateEwma(state.fastEstimate, bandwidth, weight, config.fastHalfLife),
+		fastTotalWeight: state.fastTotalWeight + weight,
+		slowEstimate: calculateEwma(state.slowEstimate, bandwidth, weight, config.slowHalfLife),
+		slowTotalWeight: state.slowTotalWeight + weight,
+		bytesSampled: updatedBytesSampled
+	};
+}
+/**
+* Get the current bandwidth estimate.
+*
+* Returns the **minimum** of the fast and slow EWMA estimates.
+* This provides the key asymmetric behavior:
+* - When bandwidth drops, fast EWMA reacts first and dominates (quick adaptation)
+* - When bandwidth rises, slow EWMA lags behind and dominates (slow adaptation)
+*
+* Uses default estimate until enough data has been sampled.
+*
+* @param state - Current estimator state
+* @param defaultEstimate - Fallback estimate before sufficient samples (bps)
+* @param config - Optional estimator configuration (uses defaults if not provided)
+* @returns Bandwidth estimate in bits per second
+*
+* @example
+* const estimate = getBandwidthEstimate(state, 5_000_000); // 5 Mbps default
+*/
+function getBandwidthEstimate(state, defaultEstimate, config = DEFAULT_BANDWIDTH_CONFIG) {
+	if (state.bytesSampled < config.minTotalBytes) return defaultEstimate;
+	const fastEstimate = applyZeroFactor(state.fastEstimate, state.fastTotalWeight, config.fastHalfLife);
+	const slowEstimate = applyZeroFactor(state.slowEstimate, state.slowTotalWeight, config.slowHalfLife);
+	return Math.min(fastEstimate, slowEstimate);
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/buffer/forward-buffer.js
+/**
+* Default forward buffer configuration.
+*/
+const DEFAULT_FORWARD_BUFFER_CONFIG = { bufferDuration: 30 };
+/**
+* Get segments that need to be loaded for forward buffer.
+*
+* Determines which segments to load to maintain target buffer duration.
+* Handles discontiguous buffering (gaps after seeks).
+*
+* Algorithm:
+* 1. Calculate target time: currentTime + bufferDuration
+* 2. Find all segments in range [currentTime, targetTime)
+* 3. Filter out segments already buffered at that time position
+* 4. Return segments to load (fills gaps + extends to target)
+*
+* @param segments - All available segments from playlist
+* @param bufferedSegments - Segments already buffered (ordered by startTime)
+* @param currentTime - Current playback position in seconds
+* @param config - Optional forward buffer configuration
+* @returns Array of segments to load (empty if buffer is sufficient)
+*
+* @example
+* // After seek: buffered [0-12, 18-30], playing at 7s
+* const toLoad = getSegmentsToLoad(segments, buffered, 7, { bufferDuration: 24 });
+* // Returns [seg-12, seg-30] (fills gap, extends to target 31s)
+*/
+/**
+* Calculate the start time from which to flush forward buffer content.
+*
+* Content that starts at or beyond `currentTime + bufferDuration` is no
+* longer needed for the current playback position and should be removed
+* from the SourceBuffer. This prevents unbounded accumulation of scattered
+* SourceBuffer content after seeks, which can cause QuotaExceededError on
+* long-form content.
+*
+* Returns `Infinity` when nothing needs flushing (no buffered segments
+* exist beyond the threshold).
+*
+* @param bufferedSegments - Segments currently tracked in the buffer model
+* @param currentTime - Current playback position in seconds
+* @param config - Optional forward buffer configuration
+* @returns Start time to flush from (flush range: [flushStart, Infinity)),
+*          or Infinity if no flush is needed
+*
+* @example
+* // Playing at 0s, buffered [0,6,12,18,24,30,36], bufferDuration=30
+* const flushStart = calculateForwardFlushPoint(segments, 0);
+* // Returns 30 — flush [30, Infinity), keep [0, 30)
+*/
+function calculateForwardFlushPoint(bufferedSegments, currentTime, config = DEFAULT_FORWARD_BUFFER_CONFIG) {
+	if (bufferedSegments.length === 0) return Infinity;
+	const threshold = currentTime + config.bufferDuration;
+	const beyond = bufferedSegments.filter((seg) => seg.startTime >= threshold);
+	if (beyond.length === 0) return Infinity;
+	return Math.min(...beyond.map((seg) => seg.startTime));
+}
+function getSegmentsToLoad(segments, bufferedSegments, currentTime, config = DEFAULT_FORWARD_BUFFER_CONFIG) {
+	if (segments.length === 0) return [];
+	const targetTime = currentTime + config.bufferDuration;
+	const bufferedStartTimes = new Set(bufferedSegments.map((seg) => seg.startTime));
+	return segments.filter((seg) => {
+		const segmentEnd = seg.startTime + seg.duration;
+		const isInRange = seg.startTime < targetTime && segmentEnd > currentTime;
+		const isNotBuffered = !bufferedStartTimes.has(seg.startTime);
+		return isInRange && isNotBuffered;
+	});
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/types/index.js
+function isResolvedTrack(track) {
+	return "segments" in track;
+}
+/**
+* Check if a presentation has duration (at least one track resolved).
+* Narrows type to include required duration.
+*/
+function hasPresentationDuration(presentation) {
+	return presentation.duration !== void 0;
+}
+
+//#endregion
+//#region ../spf/dist/dev/dom/network/chunked-stream-iterable.js
+const DEFAULT_MIN_CHUNK_SIZE = 2 ** 17;
+/**
+* Adapts a `ReadableStream<Uint8Array>` (e.g. `response.body`) into an
+* `AsyncIterable<Uint8Array>` that yields chunks no smaller than
+* `minChunkSize` bytes. Smaller network chunks are accumulated and yielded
+* together once the threshold is met. Any remainder is flushed on stream end.
+*
+* Errors from the underlying stream propagate naturally — the reader lock is
+* always released via `finally`.
+*/
+var ChunkedStreamIterable = class {
+	minChunkSize;
+	#readableStream;
+	constructor(readableStream, { minChunkSize = DEFAULT_MIN_CHUNK_SIZE } = {}) {
+		this.#readableStream = readableStream;
+		this.minChunkSize = minChunkSize;
+	}
+	async *[Symbol.asyncIterator]() {
+		let pending;
+		const reader = this.#readableStream.getReader();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					if (pending) yield pending;
+					break;
+				}
+				pending = pending ? concat(pending, value) : value;
+				if (pending.length >= this.minChunkSize) {
+					yield pending;
+					pending = void 0;
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+	}
+};
+function concat(a, b) {
+	const result = new Uint8Array(a.length + b.length);
+	result.set(a);
+	result.set(b, a.length);
+	return result;
+}
+
+//#endregion
+//#region ../spf/dist/dev/dom/network/fetch.js
+/**
+* Fetch resolvable from AddressableObject.
+*
+* Handles byte range requests if byteRange is present.
+* Returns native fetch Response for composability (can extract text, stream, etc.).
+*
+* @param addressable - Resource to fetch (url + optional byteRange)
+* @returns Promise resolving to Response
+*
+* @example
+* const response = await fetchResolvable({ url: 'https://example.com/segment.m4s' });
+* const text = await getResponseText(response);
+*
+* @example
+* // With byte range
+* const response = await fetchResolvable({
+*   url: 'https://example.com/file.mp4',
+*   byteRange: { start: 1000, end: 1999 }
+* });
+*/
+async function fetchResolvable(addressable, options) {
+	const headers = new Headers(options?.headers);
+	if (addressable.byteRange) {
+		const { start, end } = addressable.byteRange;
+		headers.set("Range", `bytes=${start}-${end}`);
+	}
+	const request = new Request(addressable.url, {
+		method: "GET",
+		headers,
+		...options
+	});
+	return fetch(request);
+}
+/**
+* Extract text from Response.
+*
+* Accepts minimal Response-like object (just needs text() method).
+* Returns promise from response.text().
+*
+* @param response - Response-like object with text() method
+* @returns Promise resolving to text content
+*
+* @example
+* const response = await fetchResolvable(addressable);
+* const text = await getResponseText(response);
+*/
+function getResponseText(response) {
+	return response.text();
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/reactive/combine-latest.js
+/**
+* Combines multiple Observable sources into a single Observable.
+*
+* Emits an array of latest values whenever any source emits.
+* Only emits after all sources have emitted at least once.
+*
+* Supports selector-based subscriptions (fires only when the selected value
+* changes, per the optional equalityFn) mirroring the createState API.
+*
+* @param sources - Array of Observable sources
+* @returns Combined Observable
+*
+* @example
+* ```ts
+* const state = createState({ count: 0 });
+* const events = createEventStream<Action>();
+*
+* combineLatest([state, events]).subscribe(([state, event]) => {
+*   if (event.type === 'PLAY' && state.count > 0) {
+*     // React to event + state condition
+*   }
+* });
+* ```
+*
+* @example Selector subscription
+* ```ts
+* combineLatest([state, owners]).subscribe(
+*   ([s, o]) => deriveKey(s, o),
+*   (key) => { ... },
+*   { equalityFn: keyEq }
+* );
+* ```
+*/
+function combineLatest(sources) {
+	const subscribeToSources = (listener) => {
+		const latest = new Array(sources.length);
+		const hasValue = new Array(sources.length).fill(false);
+		const unsubscribers = [];
+		for (let i = 0; i < sources.length; i++) {
+			const unsubscribe = sources[i].subscribe((value) => {
+				latest[i] = value;
+				hasValue[i] = true;
+				if (hasValue.every((has) => has)) listener([...latest]);
+			});
+			unsubscribers.push(unsubscribe);
+		}
+		return () => {
+			for (const unsubscribe of unsubscribers) unsubscribe();
+		};
+	};
+	return { subscribe(listenerOrSelector, maybeListener, options) {
+		if (maybeListener === void 0) return subscribeToSources(listenerOrSelector);
+		const selector = listenerOrSelector;
+		const listener = maybeListener;
+		const equalityFn = options?.equalityFn ?? Object.is;
+		let prevSelected;
+		let initialized = false;
+		return subscribeToSources((values) => {
+			const nextSelected = selector(values);
+			if (!initialized || !equalityFn(prevSelected, nextSelected)) {
+				prevSelected = nextSelected;
+				initialized = true;
+				listener(nextSelected);
+			}
+		});
+	} };
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/hls/resolve-url.js
+/**
+* Resolve a potentially relative URL against a base URL using native URL API.
+*/
+function resolveUrl(url, baseUrl) {
+	return new URL(url, baseUrl).href;
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/hls/parse-attributes.js
 /**
 * Parse HLS attribute list from a tag line.
 * Handles both quoted and unquoted values.
@@ -271,12 +699,9 @@ function matchTag(line, 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;
-}
+
+//#endregion
+//#region ../spf/dist/dev/core/hls/parse-media-playlist.js
 /**
 * Parse HLS media playlist and resolve track with segments.
 *
@@ -352,6 +777,9 @@ function parseMediaPlaylist(text, unresolved) {
 		initialization
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/utils/generate-id.js
 /**
 * Generate unique ID for HAM objects.
 *
@@ -368,6 +796,9 @@ function parseMediaPlaylist(text, unresolved) {
 function generateId() {
 	return `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/hls/parse-multivariant.js
 /**
 * Parse HLS multivariant playlist into a Presentation.
 *
@@ -460,262 +891,123 @@ function parseMultivariantPlaylist(text, unresolved) {
 			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;
+		};
+		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 {
-		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
+		id: generateId(),
+		url: unresolved.url,
+		startTime: 0,
+		selectionSets
 	};
 }
-/**
-* Get the current bandwidth estimate.
-*
-* Returns the **minimum** of the fast and slow EWMA estimates.
-* This provides the key asymmetric behavior:
-* - When bandwidth drops, fast EWMA reacts first and dominates (quick adaptation)
-* - When bandwidth rises, slow EWMA lags behind and dominates (slow adaptation)
-*
-* Uses default estimate until enough data has been sampled.
-*
-* @param state - Current estimator state
-* @param defaultEstimate - Fallback estimate before sufficient samples (bps)
-* @param config - Optional estimator configuration (uses defaults if not provided)
-* @returns Bandwidth estimate in bits per second
-*
-* @example
-* const estimate = getBandwidthEstimate(state, 5_000_000); // 5 Mbps default
-*/
-function getBandwidthEstimate(state, defaultEstimate, config = DEFAULT_BANDWIDTH_CONFIG) {
-	if (state.bytesSampled < config.minTotalBytes) return defaultEstimate;
-	const fastEstimate = applyZeroFactor(state.fastEstimate, state.fastTotalWeight, config.fastHalfLife);
-	const slowEstimate = applyZeroFactor(state.slowEstimate, state.slowTotalWeight, config.slowHalfLife);
-	return Math.min(fastEstimate, slowEstimate);
-}
+
+//#endregion
+//#region ../spf/dist/dev/core/abr/quality-selection.js
 /**
 * Default quality selection configuration.
 * Values match Shaka Player upgrade threshold (0.85 = 15% headroom).
@@ -764,125 +1056,53 @@ function selectQuality(tracks, currentBandwidth, config = DEFAULT_QUALITY_CONFIG
 function hasHigherResolution(trackA, trackB) {
 	return (trackA.width ?? 0) * (trackA.height ?? 0) > (trackB.width ?? 0) * (trackB.height ?? 0);
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/buffer/back-buffer.js
 /**
-* 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.
+* Default back buffer configuration.
 */
-function hasPresentationDuration(presentation) {
-	return presentation.duration !== void 0;
+const DEFAULT_BACK_BUFFER_CONFIG = { keepSegments: 2 };
+/**
+* Calculate back buffer flush point.
+*
+* Determines where to flush old segments from the back buffer.
+* Keeps a fixed number of segments behind the current playback position.
+*
+* Algorithm:
+* 1. Find segments before currentTime
+* 2. Count back N segments (keepSegments)
+* 3. Return startTime of segment N+1 back (flush everything before this)
+*
+* @param segments - Available segments (should be sorted by startTime)
+* @param currentTime - Current playback position in seconds
+* @param config - Optional back buffer configuration
+* @returns Time in seconds to flush up to (flush range: [0, flushEnd))
+*
+* @example
+* const segments = [
+*   { startTime: 0, duration: 6, ... },
+*   { startTime: 6, duration: 6, ... },
+*   { startTime: 12, duration: 6, ... },
+*   { startTime: 18, duration: 6, ... },
+* ];
+*
+* // Playing at 18s, keep 2 segments
+* const flushEnd = calculateBackBufferFlushPoint(segments, 18);
+* // Returns 6 (flush [0, 6), keep [6-18))
+*/
+function calculateBackBufferFlushPoint(segments, currentTime, config = DEFAULT_BACK_BUFFER_CONFIG) {
+	if (segments.length === 0) return 0;
+	const segmentsBefore = segments.filter((seg) => seg.startTime < currentTime);
+	if (segmentsBefore.length === 0) return 0;
+	const segmentsToFlush = segmentsBefore.length - config.keepSegments;
+	if (segmentsToFlush <= 0) return 0;
+	if (segmentsToFlush >= segmentsBefore.length) return currentTime;
+	return segmentsBefore[segmentsToFlush].startTime;
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/media/mediasource-setup.js
 /**
 * MediaSource Setup
 *
@@ -943,13 +1163,13 @@ function attachMediaSource(mediaSource, mediaElement) {
 	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) {
 		mediaElement.disableRemotePlayback = true;
 		mediaElement.srcObject = mediaSource;
-		const detach$1 = () => {
+		const detach = () => {
 			mediaElement.srcObject = null;
 			mediaElement.load();
 		};
 		return {
 			url: "",
-			detach: detach$1
+			detach
 		};
 	}
 	const url = URL.createObjectURL(mediaSource);
@@ -1032,99 +1252,9 @@ 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();
-}
+
+//#endregion
+//#region ../spf/dist/dev/core/events/create-event-stream.js
 /**
 * Minimal event stream with Observable-like shape.
 *
@@ -1168,73 +1298,9 @@ function createEventStream() {
 		}
 	};
 }
-/**
-* Combines multiple Observable sources into a single Observable.
-*
-* Emits an array of latest values whenever any source emits.
-* Only emits after all sources have emitted at least once.
-*
-* Supports selector-based subscriptions (fires only when the selected value
-* changes, per the optional equalityFn) mirroring the createState API.
-*
-* @param sources - Array of Observable sources
-* @returns Combined Observable
-*
-* @example
-* ```ts
-* const state = createState({ count: 0 });
-* const events = createEventStream<Action>();
-*
-* combineLatest([state, events]).subscribe(([state, event]) => {
-*   if (event.type === 'PLAY' && state.count > 0) {
-*     // React to event + state condition
-*   }
-* });
-* ```
-*
-* @example Selector subscription
-* ```ts
-* combineLatest([state, owners]).subscribe(
-*   ([s, o]) => deriveKey(s, o),
-*   (key) => { ... },
-*   { equalityFn: keyEq }
-* );
-* ```
-*/
-function combineLatest(sources) {
-	const subscribeToSources = (listener) => {
-		const latest = new Array(sources.length);
-		const hasValue = new Array(sources.length).fill(false);
-		const unsubscribers = [];
-		for (let i = 0; i < sources.length; i++) {
-			const unsubscribe = sources[i].subscribe((value) => {
-				latest[i] = value;
-				hasValue[i] = true;
-				if (hasValue.every((has) => has)) listener([...latest]);
-			});
-			unsubscribers.push(unsubscribe);
-		}
-		return () => {
-			for (const unsubscribe of unsubscribers) unsubscribe();
-		};
-	};
-	return { subscribe(listenerOrSelector, maybeListener, options) {
-		if (maybeListener === void 0) return subscribeToSources(listenerOrSelector);
-		const selector = listenerOrSelector;
-		const listener = maybeListener;
-		const equalityFn = options?.equalityFn ?? Object.is;
-		let prevSelected;
-		let initialized = false;
-		return subscribeToSources((values) => {
-			const nextSelected = selector(values);
-			if (!initialized || !equalityFn(prevSelected, nextSelected)) {
-				prevSelected = nextSelected;
-				initialized = true;
-				listener(nextSelected);
-			}
-		});
-	} };
-}
+
+//#endregion
+//#region ../spf/dist/dev/core/features/resolve-presentation.js
 /**
 * Type guard to check if presentation is unresolved.
 */
@@ -1325,6 +1391,9 @@ function resolvePresentation({ state, events }) {
 		cleanup();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/features/quality-switching.js
 /**
 * Default quality switching configuration.
 */
@@ -1385,6 +1454,9 @@ function switchQuality({ state }, config = {}) {
 		state.patch({ selectedVideoTrackId: optimal.id });
 	});
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/utils/track-selection.js
 /**
 * Map track type to selected track ID property key in state.
 */
@@ -1411,6 +1483,9 @@ function getSelectedTrack(state, type) {
 	const trackId = state[SelectedTrackIdKeyByType[type]];
 	return presentation.selectionSets.find(({ type: selectionSetType }) => selectionSetType === type)?.switchingSets[0]?.tracks.find(({ id }) => id === trackId);
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/segment-loader-actor.js
 /**
 * Creates a SegmentLoaderActor for one track type (video or audio).
 *
@@ -1600,6 +1675,9 @@ function createSegmentLoaderActor(sourceBufferActor, fetchBytes) {
 		}
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/load-segments.js
 const ActorKeyByType = {
 	video: "videoBufferActor",
 	audio: "audioBufferActor"
@@ -1750,7 +1828,7 @@ function loadSegments({ state, owners }, config) {
 		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 }) => {
+	const unsubscribeShouldLoadSegments = combineLatest([segmentsCanLoad, state]).subscribe(([segmentsCanLoad, state]) => selectLoadingInputs([segmentsCanLoad, state], type), ({ preload, playbackInitiated, currentTime, track }) => {
 		if (!(preload === "auto" || !!playbackInitiated))
  /** @ts-expect-error */
 		segmentLoader.current?.send({
@@ -1772,6 +1850,9 @@ function loadSegments({ state, owners }, config) {
 		unsubActorLifecycle();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/text/parse-vtt-segment.js
 /**
 * Parse a VTT segment using browser's native parser.
 *
@@ -1823,6 +1904,9 @@ function parseVttSegment(url) {
 function destroyVttParser() {
 	dummyVideo = null;
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/load-text-track-cues.js
 function isDuplicateCue(cue, textTrack) {
 	const { cues } = textTrack;
 	if (!cues) return false;
@@ -1964,6 +2048,9 @@ function loadTextTrackCues({ state, owners }) {
 		cleanup();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/track-current-time.js
 /**
 * Track current playback position from the media element.
 *
@@ -2003,6 +2090,9 @@ function trackCurrentTime({ state, owners }) {
 		unsubscribe();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/track-playback-initiated.js
 /**
 * Track whether playback has been initiated by the user.
 *
@@ -2051,6 +2141,9 @@ function trackPlaybackInitiated({ state, owners, events }) {
 		unsubscribeOwners();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/media/append-segment.js
 /**
 * Append media data to a SourceBuffer.
 *
@@ -2106,6 +2199,9 @@ async function appendChunk(sourceBuffer, data) {
 		}
 	});
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/media/buffer-flusher.js
 /**
 * Buffer flusher helper (P12)
 *
@@ -2156,6 +2252,9 @@ async function flushBuffer(sourceBuffer, start, end) {
 		}
 	});
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/features/calculate-presentation-duration.js
 /**
 * Check if we can calculate presentation duration (have required data).
 */
@@ -2198,6 +2297,9 @@ function calculatePresentationDuration({ state }) {
 		} });
 	});
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/task.js
 /**
 * Generic reusable task that wraps an async run function.
 *
@@ -2313,6 +2415,9 @@ var SerialRunner = class {
 		this.abortAll();
 	}
 };
+
+//#endregion
+//#region ../spf/dist/dev/core/features/resolve-track.js
 function canResolve(state, config) {
 	const track = getSelectedTrack(state, config.type);
 	if (!track) return false;
@@ -2378,6 +2483,9 @@ function resolveTrack({ state, events }, config) {
 		cleanup();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/features/select-tracks.js
 /**
 * Pick text track to activate.
 *
@@ -2518,6 +2626,9 @@ function selectTextTrack({ state }, config = { type: "text" }) {
 		}
 	});
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/end-of-stream.js
 /**
 * Check if the last segment of a track has been appended to a SourceBuffer.
 *
@@ -2678,6 +2789,9 @@ function endOfStream({ state, owners }) {
 		cleanupCombineLatest();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/setup-mediasource.js
 /**
 * Check if we have the minimum requirements to create MediaSource.
 */
@@ -2724,6 +2838,9 @@ function setupMediaSource({ state, owners }) {
 		unsubscribe();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/media/source-buffer-actor.js
 /**
 * Thrown when a message is sent to the actor in a state that does not
 * accept messages (currently: 'updating').
@@ -2900,6 +3017,9 @@ function createSourceBufferActor(sourceBuffer, initialContext) {
 		}
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/setup-sourcebuffer.js
 /**
 * Build MIME codec string from track metadata.
 *
@@ -2958,6 +3078,9 @@ function setupSourceBuffers({ state, owners }) {
 		await new Promise((resolve) => requestAnimationFrame(resolve));
 	});
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/setup-text-tracks.js
 /**
 * Get all text tracks from presentation.
 */
@@ -3039,6 +3162,9 @@ function setupTextTracks({ state, owners }) {
 		unsubscribe();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/sync-selected-text-track-from-dom.js
 /**
 * Sync selectedTextTrackId from DOM text track mode changes.
 *
@@ -3095,6 +3221,9 @@ function syncSelectedTextTrackFromDom({ state, owners }) {
 		unsubscribe();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/sync-text-track-modes.js
 /**
 * Check if we can sync text track modes.
 *
@@ -3126,6 +3255,9 @@ function syncTextTrackModes({ state, owners }) {
 		else trackElement.track.mode = "hidden";
 	});
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/update-duration.js
 /**
 * Check if we can update MediaSource duration (have required data).
 */
@@ -3190,6 +3322,9 @@ function updateDuration({ state, owners }) {
 		unsubscribe();
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/playback-engine/engine.js
 /**
 * Create a POC playback engine.
 *
@@ -3341,6 +3476,9 @@ function createPlaybackEngine(config = {}) {
 		}
 	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/playback-engine/adapter.js
 /**
 * HTMLMediaElement-compatible adapter for the SPF playback engine.
 *