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

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

@@ -1,151 +1,10 @@
-import { n as isNil } from "../predicate-BG-dj_kF.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";
+import { t as anyAbortSignal } from "../abort-JT-ewLFq.js";
+import { t as safeDefine } from "../safe-define-D26LrTu4.js";
+import { t as listen } from "../listen-BkAEGXCe.js";
+import { t as DelegateMixin } from "../delegate-CSc5c0ZR.js";
+import { t as MediaAttachMixin } from "../media-attach-mixin-Dsn4gxJA.js";
+import { n as CustomVideoElement, t as MediaPropsMixin } from "../media-props-mixin-DxsM38Bx.js";
 
-//#region ../spf/dist/dev/core/state/create-state.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 = selectorOrListener;
-			this.#listeners.add(listener);
-			listener(this.current);
-			return () => {
-				this.#listeners.delete(listener);
-			};
-		}
-		const selector = selectorOrListener;
-		const listener = maybeListener;
-		const entry = {
-			selector,
-			listener,
-			options: options ?? {}
-		};
-		this.#selectorListeners.add(entry);
-		listener(selector(this.current));
-		return () => {
-			this.#selectorListeners.delete(entry);
-		};
-	}
-	flush() {
-		if (this.#pending === null) return;
-		const prev = this.#current;
-		const next = this.#pending;
-		this.#pending = null;
-		this.#pendingFlush = false;
-		if (this.#equalityFn(prev, next)) return;
-		this.#current = next;
-		for (const listener of this.#listeners) listener(this.#current);
-		for (const entry of this.#selectorListeners) {
-			const prevSelected = entry.selector(prev);
-			const nextSelected = entry.selector(this.#current);
-			if (!(entry.options.equalityFn ?? Object.is)(prevSelected, nextSelected)) entry.listener(nextSelected);
-		}
-	}
-	#scheduleFlush() {
-		if (this.#pendingFlush) return;
-		this.#pendingFlush = true;
-		queueMicrotask(() => this.flush());
-	}
-};
-/**
-* Create a reactive state container.
-*
-* @example
-* ```typescript
-* const state = createState({ count: 0 });
-*
-* // Subscribe to changes
-* state.subscribe((current, prev) => {
-*   console.log('Changed:', prev, '->', current);
-* });
-*
-* // Updates are batched
-* state.patch({ count: 1 });
-* state.patch({ count: 2 });
-* // Only one notification fires (with count: 2)
-* ```
-*
-* @example Selector subscriptions
-* ```typescript
-* const state = createState({ count: 0, name: 'test' });
-*
-* // Only notified when count changes
-* state.subscribe(
-*   s => s.count,
-*   (current, prev) => console.log(current, prev)
-* );
-* ```
-*
-* @example Custom equality
-* ```typescript
-* const state = createState(
-*   { count: 0, name: 'test' },
-*   { equalityFn: (a, b) => a.count === b.count }
-* );
-* ```
-*/
-function createState(initial, config) {
-	return new StateContainer(initial, config);
-}
-
-//#endregion
 //#region ../spf/dist/dev/core/abr/ewma.js
 /**
 * Exponentially Weighted Moving Average (EWMA)
@@ -377,6 +236,558 @@ function getSegmentsToLoad(segments, bufferedSegments, currentTime, config = DEF
 	});
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/signal-polyfill@0.2.2/node_modules/signal-polyfill/dist/index.js
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+	__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+	return value;
+};
+var __accessCheck = (obj, member, msg) => {
+	if (!member.has(obj)) throw TypeError("Cannot " + msg);
+};
+var __privateIn = (member, obj) => {
+	if (Object(obj) !== obj) throw TypeError("Cannot use the \"in\" operator on this value");
+	return member.has(obj);
+};
+var __privateAdd = (obj, member, value) => {
+	if (member.has(obj)) throw TypeError("Cannot add the same private member more than once");
+	member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+	__accessCheck(obj, member, "access private method");
+	return method;
+};
+/**
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+function defaultEquals(a, b) {
+	return Object.is(a, b);
+}
+/**
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+let activeConsumer = null;
+let inNotificationPhase = false;
+let epoch = 1;
+const SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
+function setActiveConsumer(consumer) {
+	const prev = activeConsumer;
+	activeConsumer = consumer;
+	return prev;
+}
+function getActiveConsumer() {
+	return activeConsumer;
+}
+function isInNotificationPhase() {
+	return inNotificationPhase;
+}
+const REACTIVE_NODE = {
+	version: 0,
+	lastCleanEpoch: 0,
+	dirty: false,
+	producerNode: void 0,
+	producerLastReadVersion: void 0,
+	producerIndexOfThis: void 0,
+	nextProducerIndex: 0,
+	liveConsumerNode: void 0,
+	liveConsumerIndexOfThis: void 0,
+	consumerAllowSignalWrites: false,
+	consumerIsAlwaysLive: false,
+	producerMustRecompute: () => false,
+	producerRecomputeValue: () => {},
+	consumerMarkedDirty: () => {},
+	consumerOnSignalRead: () => {}
+};
+function producerAccessed(node) {
+	if (inNotificationPhase) throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? `Assertion error: signal read during notification phase` : "");
+	if (activeConsumer === null) return;
+	activeConsumer.consumerOnSignalRead(node);
+	const idx = activeConsumer.nextProducerIndex++;
+	assertConsumerNode(activeConsumer);
+	if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {
+		if (consumerIsLive(activeConsumer)) {
+			const staleProducer = activeConsumer.producerNode[idx];
+			producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);
+		}
+	}
+	if (activeConsumer.producerNode[idx] !== node) {
+		activeConsumer.producerNode[idx] = node;
+		activeConsumer.producerIndexOfThis[idx] = consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
+	}
+	activeConsumer.producerLastReadVersion[idx] = node.version;
+}
+function producerIncrementEpoch() {
+	epoch++;
+}
+function producerUpdateValueVersion(node) {
+	if (!node.dirty && node.lastCleanEpoch === epoch) return;
+	if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
+		node.dirty = false;
+		node.lastCleanEpoch = epoch;
+		return;
+	}
+	node.producerRecomputeValue(node);
+	node.dirty = false;
+	node.lastCleanEpoch = epoch;
+}
+function producerNotifyConsumers(node) {
+	if (node.liveConsumerNode === void 0) return;
+	const prev = inNotificationPhase;
+	inNotificationPhase = true;
+	try {
+		for (const consumer of node.liveConsumerNode) if (!consumer.dirty) consumerMarkDirty(consumer);
+	} finally {
+		inNotificationPhase = prev;
+	}
+}
+function producerUpdatesAllowed() {
+	return (activeConsumer == null ? void 0 : activeConsumer.consumerAllowSignalWrites) !== false;
+}
+function consumerMarkDirty(node) {
+	var _a;
+	node.dirty = true;
+	producerNotifyConsumers(node);
+	(_a = node.consumerMarkedDirty) == null || _a.call(node.wrapper ?? node);
+}
+function consumerBeforeComputation(node) {
+	node && (node.nextProducerIndex = 0);
+	return setActiveConsumer(node);
+}
+function consumerAfterComputation(node, prevConsumer) {
+	setActiveConsumer(prevConsumer);
+	if (!node || node.producerNode === void 0 || node.producerIndexOfThis === void 0 || node.producerLastReadVersion === void 0) return;
+	if (consumerIsLive(node)) for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+	while (node.producerNode.length > node.nextProducerIndex) {
+		node.producerNode.pop();
+		node.producerLastReadVersion.pop();
+		node.producerIndexOfThis.pop();
+	}
+}
+function consumerPollProducersForChange(node) {
+	assertConsumerNode(node);
+	for (let i = 0; i < node.producerNode.length; i++) {
+		const producer = node.producerNode[i];
+		const seenVersion = node.producerLastReadVersion[i];
+		if (seenVersion !== producer.version) return true;
+		producerUpdateValueVersion(producer);
+		if (seenVersion !== producer.version) return true;
+	}
+	return false;
+}
+function producerAddLiveConsumer(node, consumer, indexOfThis) {
+	var _a;
+	assertProducerNode(node);
+	assertConsumerNode(node);
+	if (node.liveConsumerNode.length === 0) {
+		(_a = node.watched) == null || _a.call(node.wrapper);
+		for (let i = 0; i < node.producerNode.length; i++) node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
+	}
+	node.liveConsumerIndexOfThis.push(indexOfThis);
+	return node.liveConsumerNode.push(consumer) - 1;
+}
+function producerRemoveLiveConsumerAtIndex(node, idx) {
+	var _a;
+	assertProducerNode(node);
+	assertConsumerNode(node);
+	if (typeof ngDevMode !== "undefined" && ngDevMode && idx >= node.liveConsumerNode.length) throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
+	if (node.liveConsumerNode.length === 1) {
+		(_a = node.unwatched) == null || _a.call(node.wrapper);
+		for (let i = 0; i < node.producerNode.length; i++) producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+	}
+	const lastIdx = node.liveConsumerNode.length - 1;
+	node.liveConsumerNode[idx] = node.liveConsumerNode[lastIdx];
+	node.liveConsumerIndexOfThis[idx] = node.liveConsumerIndexOfThis[lastIdx];
+	node.liveConsumerNode.length--;
+	node.liveConsumerIndexOfThis.length--;
+	if (idx < node.liveConsumerNode.length) {
+		const idxProducer = node.liveConsumerIndexOfThis[idx];
+		const consumer = node.liveConsumerNode[idx];
+		assertConsumerNode(consumer);
+		consumer.producerIndexOfThis[idxProducer] = idx;
+	}
+}
+function consumerIsLive(node) {
+	var _a;
+	return node.consumerIsAlwaysLive || (((_a = node == null ? void 0 : node.liveConsumerNode) == null ? void 0 : _a.length) ?? 0) > 0;
+}
+function assertConsumerNode(node) {
+	node.producerNode ?? (node.producerNode = []);
+	node.producerIndexOfThis ?? (node.producerIndexOfThis = []);
+	node.producerLastReadVersion ?? (node.producerLastReadVersion = []);
+}
+function assertProducerNode(node) {
+	node.liveConsumerNode ?? (node.liveConsumerNode = []);
+	node.liveConsumerIndexOfThis ?? (node.liveConsumerIndexOfThis = []);
+}
+/**
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+function computedGet(node) {
+	producerUpdateValueVersion(node);
+	producerAccessed(node);
+	if (node.value === ERRORED) throw node.error;
+	return node.value;
+}
+function createComputed(computation) {
+	const node = Object.create(COMPUTED_NODE);
+	node.computation = computation;
+	const computed = () => computedGet(node);
+	computed[SIGNAL] = node;
+	return computed;
+}
+const UNSET = /* @__PURE__ */ Symbol("UNSET");
+const COMPUTING = /* @__PURE__ */ Symbol("COMPUTING");
+const ERRORED = /* @__PURE__ */ Symbol("ERRORED");
+const COMPUTED_NODE = {
+	...REACTIVE_NODE,
+	value: UNSET,
+	dirty: true,
+	error: null,
+	equal: defaultEquals,
+	producerMustRecompute(node) {
+		return node.value === UNSET || node.value === COMPUTING;
+	},
+	producerRecomputeValue(node) {
+		if (node.value === COMPUTING) throw new Error("Detected cycle in computations.");
+		const oldValue = node.value;
+		node.value = COMPUTING;
+		const prevConsumer = consumerBeforeComputation(node);
+		let newValue;
+		let wasEqual = false;
+		try {
+			newValue = node.computation.call(node.wrapper);
+			wasEqual = oldValue !== UNSET && oldValue !== ERRORED && node.equal.call(node.wrapper, oldValue, newValue);
+		} catch (err) {
+			newValue = ERRORED;
+			node.error = err;
+		} finally {
+			consumerAfterComputation(node, prevConsumer);
+		}
+		if (wasEqual) {
+			node.value = oldValue;
+			return;
+		}
+		node.value = newValue;
+		node.version++;
+	}
+};
+/**
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+function defaultThrowError() {
+	throw new Error();
+}
+let throwInvalidWriteToSignalErrorFn = defaultThrowError;
+function throwInvalidWriteToSignalError() {
+	throwInvalidWriteToSignalErrorFn();
+}
+/**
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+function createSignal(initialValue) {
+	const node = Object.create(SIGNAL_NODE);
+	node.value = initialValue;
+	const getter = () => {
+		producerAccessed(node);
+		return node.value;
+	};
+	getter[SIGNAL] = node;
+	return getter;
+}
+function signalGetFn() {
+	producerAccessed(this);
+	return this.value;
+}
+function signalSetFn(node, newValue) {
+	if (!producerUpdatesAllowed()) throwInvalidWriteToSignalError();
+	if (!node.equal.call(node.wrapper, node.value, newValue)) {
+		node.value = newValue;
+		signalValueChanged(node);
+	}
+}
+const SIGNAL_NODE = {
+	...REACTIVE_NODE,
+	equal: defaultEquals,
+	value: void 0
+};
+function signalValueChanged(node) {
+	node.version++;
+	producerIncrementEpoch();
+	producerNotifyConsumers(node);
+}
+/**
+* @license
+* Copyright 2024 Bloomberg Finance L.P.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+const NODE = Symbol("node");
+var Signal;
+((Signal2) => {
+	var _a, _brand, _b, _brand2;
+	class State {
+		constructor(initialValue, options = {}) {
+			__privateAdd(this, _brand);
+			__publicField(this, _a);
+			const node = createSignal(initialValue)[SIGNAL];
+			this[NODE] = node;
+			node.wrapper = this;
+			if (options) {
+				const equals = options.equals;
+				if (equals) node.equal = equals;
+				node.watched = options[Signal2.subtle.watched];
+				node.unwatched = options[Signal2.subtle.unwatched];
+			}
+		}
+		get() {
+			if (!(0, Signal2.isState)(this)) throw new TypeError("Wrong receiver type for Signal.State.prototype.get");
+			return signalGetFn.call(this[NODE]);
+		}
+		set(newValue) {
+			if (!(0, Signal2.isState)(this)) throw new TypeError("Wrong receiver type for Signal.State.prototype.set");
+			if (isInNotificationPhase()) throw new Error("Writes to signals not permitted during Watcher callback");
+			const ref = this[NODE];
+			signalSetFn(ref, newValue);
+		}
+	}
+	_a = NODE;
+	_brand = /* @__PURE__ */ new WeakSet();
+	Signal2.isState = (s) => typeof s === "object" && __privateIn(_brand, s);
+	Signal2.State = State;
+	class Computed {
+		constructor(computation, options) {
+			__privateAdd(this, _brand2);
+			__publicField(this, _b);
+			const node = createComputed(computation)[SIGNAL];
+			node.consumerAllowSignalWrites = true;
+			this[NODE] = node;
+			node.wrapper = this;
+			if (options) {
+				const equals = options.equals;
+				if (equals) node.equal = equals;
+				node.watched = options[Signal2.subtle.watched];
+				node.unwatched = options[Signal2.subtle.unwatched];
+			}
+		}
+		get() {
+			if (!(0, Signal2.isComputed)(this)) throw new TypeError("Wrong receiver type for Signal.Computed.prototype.get");
+			return computedGet(this[NODE]);
+		}
+	}
+	_b = NODE;
+	_brand2 = /* @__PURE__ */ new WeakSet();
+	Signal2.isComputed = (c) => typeof c === "object" && __privateIn(_brand2, c);
+	Signal2.Computed = Computed;
+	((subtle2) => {
+		var _a2, _brand3, _assertSignals, assertSignals_fn;
+		function untrack(cb) {
+			let output;
+			let prevActiveConsumer = null;
+			try {
+				prevActiveConsumer = setActiveConsumer(null);
+				output = cb();
+			} finally {
+				setActiveConsumer(prevActiveConsumer);
+			}
+			return output;
+		}
+		subtle2.untrack = untrack;
+		function introspectSources(sink) {
+			var _a3;
+			if (!(0, Signal2.isComputed)(sink) && !(0, Signal2.isWatcher)(sink)) throw new TypeError("Called introspectSources without a Computed or Watcher argument");
+			return ((_a3 = sink[NODE].producerNode) == null ? void 0 : _a3.map((n) => n.wrapper)) ?? [];
+		}
+		subtle2.introspectSources = introspectSources;
+		function introspectSinks(signal) {
+			var _a3;
+			if (!(0, Signal2.isComputed)(signal) && !(0, Signal2.isState)(signal)) throw new TypeError("Called introspectSinks without a Signal argument");
+			return ((_a3 = signal[NODE].liveConsumerNode) == null ? void 0 : _a3.map((n) => n.wrapper)) ?? [];
+		}
+		subtle2.introspectSinks = introspectSinks;
+		function hasSinks(signal) {
+			if (!(0, Signal2.isComputed)(signal) && !(0, Signal2.isState)(signal)) throw new TypeError("Called hasSinks without a Signal argument");
+			const liveConsumerNode = signal[NODE].liveConsumerNode;
+			if (!liveConsumerNode) return false;
+			return liveConsumerNode.length > 0;
+		}
+		subtle2.hasSinks = hasSinks;
+		function hasSources(signal) {
+			if (!(0, Signal2.isComputed)(signal) && !(0, Signal2.isWatcher)(signal)) throw new TypeError("Called hasSources without a Computed or Watcher argument");
+			const producerNode = signal[NODE].producerNode;
+			if (!producerNode) return false;
+			return producerNode.length > 0;
+		}
+		subtle2.hasSources = hasSources;
+		class Watcher {
+			constructor(notify) {
+				__privateAdd(this, _brand3);
+				__privateAdd(this, _assertSignals);
+				__publicField(this, _a2);
+				let node = Object.create(REACTIVE_NODE);
+				node.wrapper = this;
+				node.consumerMarkedDirty = notify;
+				node.consumerIsAlwaysLive = true;
+				node.consumerAllowSignalWrites = false;
+				node.producerNode = [];
+				this[NODE] = node;
+			}
+			watch(...signals) {
+				if (!(0, Signal2.isWatcher)(this)) throw new TypeError("Called unwatch without Watcher receiver");
+				__privateMethod(this, _assertSignals, assertSignals_fn).call(this, signals);
+				const node = this[NODE];
+				node.dirty = false;
+				const prev = setActiveConsumer(node);
+				for (const signal of signals) producerAccessed(signal[NODE]);
+				setActiveConsumer(prev);
+			}
+			unwatch(...signals) {
+				if (!(0, Signal2.isWatcher)(this)) throw new TypeError("Called unwatch without Watcher receiver");
+				__privateMethod(this, _assertSignals, assertSignals_fn).call(this, signals);
+				const node = this[NODE];
+				assertConsumerNode(node);
+				for (let i = node.producerNode.length - 1; i >= 0; i--) if (signals.includes(node.producerNode[i].wrapper)) {
+					producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+					const lastIdx = node.producerNode.length - 1;
+					node.producerNode[i] = node.producerNode[lastIdx];
+					node.producerIndexOfThis[i] = node.producerIndexOfThis[lastIdx];
+					node.producerNode.length--;
+					node.producerIndexOfThis.length--;
+					node.nextProducerIndex--;
+					if (i < node.producerNode.length) {
+						const idxConsumer = node.producerIndexOfThis[i];
+						const producer = node.producerNode[i];
+						assertProducerNode(producer);
+						producer.liveConsumerIndexOfThis[idxConsumer] = i;
+					}
+				}
+			}
+			getPending() {
+				if (!(0, Signal2.isWatcher)(this)) throw new TypeError("Called getPending without Watcher receiver");
+				return this[NODE].producerNode.filter((n) => n.dirty).map((n) => n.wrapper);
+			}
+		}
+		_a2 = NODE;
+		_brand3 = /* @__PURE__ */ new WeakSet();
+		_assertSignals = /* @__PURE__ */ new WeakSet();
+		assertSignals_fn = function(signals) {
+			for (const signal of signals) if (!(0, Signal2.isComputed)(signal) && !(0, Signal2.isState)(signal)) throw new TypeError("Called watch/unwatch without a Computed or State argument");
+		};
+		Signal2.isWatcher = (w) => __privateIn(_brand3, w);
+		subtle2.Watcher = Watcher;
+		function currentComputed() {
+			var _a3;
+			return (_a3 = getActiveConsumer()) == null ? void 0 : _a3.wrapper;
+		}
+		subtle2.currentComputed = currentComputed;
+		subtle2.watched = Symbol("watched");
+		subtle2.unwatched = Symbol("unwatched");
+	})(Signal2.subtle || (Signal2.subtle = {}));
+})(Signal || (Signal = {}));
+
+//#endregion
+//#region ../spf/dist/dev/core/signals/effect.js
+const pending = /* @__PURE__ */ new Set();
+const watcher = new Signal.subtle.Watcher(() => {
+	queueMicrotask(runPending);
+});
+function runPending() {
+	for (const c of watcher.getPending()) pending.add(c);
+	watcher.watch();
+	for (const c of pending) {
+		pending.delete(c);
+		c.get();
+	}
+}
+/**
+* Run a side effect whenever its signal dependencies change.
+*
+* Executes immediately (synchronous initial run), then re-runs on the next
+* microtask after any dependency changes. If the callback returns a function,
+* it is called before each re-run and when the effect is stopped — the same
+* cleanup contract as Preact Signals, Maverick Signals, and Svelte 5 $effect.
+*
+* Returns a cleanup function that stops the effect.
+*/
+function effect(fn) {
+	let cleanup;
+	const c = new Signal.Computed(() => {
+		if (typeof cleanup === "function") cleanup();
+		cleanup = fn();
+	});
+	watcher.watch(c);
+	c.get();
+	return () => {
+		watcher.unwatch(c);
+		if (typeof cleanup === "function") cleanup();
+	};
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/signals/primitives.js
+/** Read a signal value without tracking it as a dependency. */
+const untrack = Signal.subtle.untrack;
+/** Create a writable reactive value. */
+function signal(initialValue, options) {
+	return new Signal.State(initialValue, options);
+}
+/** Create a computed reactive value. */
+function computed(fn, options) {
+	return new Signal.Computed(fn, options);
+}
+/**
+* Update a writable signal. Accepts either a partial object to merge into the
+* current state, or an updater function that receives the current state and
+* returns the next state.
+*
+* @example
+* update(state, { playbackRate: 2 });
+* update(state, (s) => ({ ...s, count: s.count + 1 }));
+*/
+function update(signal, updater) {
+	const current = untrack(() => signal.get());
+	signal.set(typeof updater === "function" ? updater(current) : {
+		...current,
+		...updater
+	});
+}
+
 //#endregion
 //#region ../spf/dist/dev/core/types/index.js
 function isResolvedTrack(track) {
@@ -390,6 +801,43 @@ function hasPresentationDuration(presentation) {
 	return presentation.duration !== void 0;
 }
 
+//#endregion
+//#region ../spf/dist/dev/core/utils/track-selection.js
+/**
+* Map track type to selected track ID property key in state.
+*/
+const SelectedTrackIdKeyByType = {
+	video: "selectedVideoTrackId",
+	audio: "selectedAudioTrackId",
+	text: "selectedTextTrackId"
+};
+/**
+* Map track type to buffer owner property key.
+* Used for SourceBuffer references in owners.
+*/
+const BufferKeyByType = {
+	video: "videoBuffer",
+	audio: "audioBuffer"
+};
+/**
+* Get selected track from state by type.
+* Returns properly typed track (partially or fully resolved) or undefined.
+* Type parameter T is inferred from the type argument.
+*
+* @example
+* const videoTrack = getSelectedTrack(state, 'video');
+* if (videoTrack && isResolvedTrack(videoTrack)) {
+*   // videoTrack is VideoTrack
+* }
+*/
+function getSelectedTrack(state, type) {
+	const { presentation } = state;
+	/** @TODO Consider moving and reusing isUnresolved(presentation) (CJP) */
+	if (!presentation || !("id" in presentation)) return void 0;
+	const trackId = state[SelectedTrackIdKeyByType[type]];
+	return presentation.selectionSets.find(({ type: selectionSetType }) => selectionSetType === type)?.switchingSets[0]?.tracks.find(({ id }) => id === trackId);
+}
+
 //#endregion
 //#region ../spf/dist/dev/dom/network/chunked-stream-iterable.js
 const DEFAULT_MIN_CHUNK_SIZE = 2 ** 17;
@@ -490,1812 +938,1511 @@ function getResponseText(response) {
 }
 
 //#endregion
-//#region ../spf/dist/dev/core/reactive/combine-latest.js
+//#region ../spf/dist/dev/core/buffer/back-buffer.js
+/**
+* Default back buffer configuration.
+*/
+const DEFAULT_BACK_BUFFER_CONFIG = { keepSegments: 2 };
 /**
-* Combines multiple Observable sources into a single Observable.
+* Calculate back buffer flush point.
 *
-* Emits an array of latest values whenever any source emits.
-* Only emits after all sources have emitted at least once.
+* Determines where to flush old segments from the back buffer.
+* Keeps a fixed number of segments behind the current playback position.
 *
-* Supports selector-based subscriptions (fires only when the selected value
-* changes, per the optional equalityFn) mirroring the createState API.
+* 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 sources - Array of Observable sources
-* @returns Combined Observable
+* @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
-* ```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
-*   }
-* });
-* ```
+* const segments = [
+*   { startTime: 0, duration: 6, ... },
+*   { startTime: 6, duration: 6, ... },
+*   { startTime: 12, duration: 6, ... },
+*   { startTime: 18, duration: 6, ... },
+* ];
 *
-* @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.
+* // Playing at 18s, keep 2 segments
+* const flushEnd = calculateBackBufferFlushPoint(segments, 18);
+* // Returns 6 (flush [0, 6), keep [6-18))
 */
-function resolveUrl(url, baseUrl) {
-	return new URL(url, baseUrl).href;
+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/core/hls/parse-attributes.js
+//#region ../spf/dist/dev/dom/features/segment-loader-actor.js
 /**
-* Parse HLS attribute list from a tag line.
-* Handles both quoted and unquoted values.
+* 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 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
+function createSegmentLoaderActor(sourceBufferActor, fetchBytes) {
+	let pendingTasks = null;
+	let inFlightInitTrackId = null;
+	let inFlightSegmentId = null;
+	let abortController = null;
+	let running = false;
+	let destroyed = false;
+	const getBufferedSegments = (allSegments) => {
+		const bufferedIds = new Set(sourceBufferActor.snapshot.get().context.segments.filter((s) => !s.partial).map((s) => s.id));
+		return allSegments.filter((s) => bufferedIds.has(s.id));
 	};
-	if (Math.abs(fps - 59.94) < .01) return {
-		frameRateNumerator: 6e4,
-		frameRateDenominator: 1001
+	/**
+	* Translate a load message into an ordered LoadTask list based on committed
+	* actor state. In-flight awareness is handled separately in send().
+	*
+	* @todo Rename alongside LoadTask (e.g. planOps).
+	*
+	* Case 1 — Removes: forward and back buffer flush points, segment-aligned.
+	*   No flush on track switch: appending new content overwrites existing buffer
+	*   ranges, and the actor's time-aligned deduplication keeps the segment model
+	*   accurate as new segments arrive.
+	*
+	* Case 2 — Init: schedule if not yet committed for this track.
+	*
+	* Case 3 — Segments: all segments in the load window not yet committed.
+	*/
+	const planTasks = (message) => {
+		const { track, range } = message;
+		const actorCtx = sourceBufferActor.snapshot.get().context;
+		const bufferedSegments = getBufferedSegments(track.segments);
+		const currentTime = range?.start ?? 0;
+		const tasks = [];
+		if (range) {
+			const forwardFlushStart = calculateForwardFlushPoint(bufferedSegments, currentTime);
+			if (forwardFlushStart < Infinity) tasks.push({
+				type: "remove",
+				start: forwardFlushStart,
+				end: Infinity
+			});
+			const backFlushEnd = calculateBackBufferFlushPoint(bufferedSegments, currentTime);
+			if (backFlushEnd > 0) tasks.push({
+				type: "remove",
+				start: 0,
+				end: backFlushEnd
+			});
+		}
+		if (actorCtx.initTrackId !== track.id) tasks.push({
+			type: "append-init",
+			meta: { trackId: track.id },
+			url: track.initialization.url,
+			...track.initialization.byteRange !== void 0 && { byteRange: track.initialization.byteRange }
+		});
+		if (range) {
+			const EPSILON = 1e-4;
+			const segmentsToLoad = getSegmentsToLoad(track.segments, bufferedSegments, currentTime).filter((seg) => {
+				const existing = actorCtx.segments.find((s) => Math.abs(s.startTime - seg.startTime) < EPSILON);
+				if (existing?.partial) return true;
+				if (!existing?.trackBandwidth || !track.bandwidth) return true;
+				return track.bandwidth > existing.trackBandwidth;
+			});
+			for (const segment of segmentsToLoad) tasks.push({
+				type: "append-segment",
+				meta: {
+					id: segment.id,
+					startTime: segment.startTime,
+					duration: segment.duration,
+					trackId: track.id,
+					trackBandwidth: track.bandwidth
+				},
+				url: segment.url,
+				...segment.byteRange !== void 0 && { byteRange: segment.byteRange }
+			});
+		}
+		return tasks;
 	};
-	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
+	/**
+	* 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;
+		}
 	};
-}
-/**
-* 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);
+	/**
+	* 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;
 	};
-}
-/**
-* Match a tag and extract its attributes.
-* Returns null if the line doesn't match the tag.
-*/
-function matchTag(line, tag) {
-	const prefix = `#${tag}:`;
-	if (!line.startsWith(prefix)) return null;
-	return createAttributeList(line.slice(prefix.length));
-}
-
-//#endregion
-//#region ../spf/dist/dev/core/hls/parse-media-playlist.js
-/**
-* Parse HLS media playlist and resolve track with segments.
-*
-* Takes an unresolved track (from multivariant playlist) and media playlist text,
-* returns a HAM-compliant resolved track with segments.
-*
-* @param text - Media playlist text content
-* @param unresolved - Unresolved track from parseMultivariantPlaylist
-* @returns Resolved track with segments (type inferred from input)
-*/
-function parseMediaPlaylist(text, unresolved) {
-	const lines = text.split(/\r?\n/);
-	const baseUrl = unresolved.url;
-	const segments = [];
-	let initSegmentUrl;
-	let initSegmentByteRange;
-	let currentDuration = 0;
-	let currentByteRange;
-	let currentTime = 0;
-	let segmentIndex = 0;
-	let previousByteRangeEnd;
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#") && !trimmed.startsWith("#EXT")) continue;
-		if (trimmed === "#EXTM3U" || trimmed.startsWith("#EXT-X-VERSION:") || trimmed.startsWith("#EXT-X-TARGETDURATION:") || trimmed.startsWith("#EXT-X-PLAYLIST-TYPE:") || trimmed.startsWith("#EXT-X-INDEPENDENT-SEGMENTS")) continue;
-		const mapAttrs = matchTag(trimmed, "EXT-X-MAP");
-		if (mapAttrs) {
-			const uri = mapAttrs.get("URI");
-			if (uri) {
-				initSegmentUrl = resolveUrl(uri, baseUrl);
-				const byteRangeStr = mapAttrs.get("BYTERANGE");
-				if (byteRangeStr) initSegmentByteRange = parseByteRange(byteRangeStr, 0) ?? void 0;
-			}
-			continue;
-		}
-		if (trimmed.startsWith("#EXTINF:")) {
-			currentDuration = parseExtInfDuration(trimmed.slice(8));
-			continue;
-		}
-		if (trimmed.startsWith("#EXT-X-BYTERANGE:")) {
-			currentByteRange = parseByteRange(trimmed.slice(17), previousByteRangeEnd) ?? void 0;
-			continue;
-		}
-		if (trimmed === "#EXT-X-ENDLIST") continue;
-		if (!trimmed.startsWith("#") && currentDuration > 0) {
-			const segment = {
-				id: `segment-${segmentIndex}`,
-				url: resolveUrl(trimmed, baseUrl),
-				duration: currentDuration,
-				startTime: currentTime
-			};
-			if (currentByteRange) {
-				segment.byteRange = currentByteRange;
-				previousByteRangeEnd = currentByteRange.end + 1;
-			} else previousByteRangeEnd = void 0;
-			segments.push(segment);
-			currentTime += currentDuration;
-			segmentIndex++;
-			currentDuration = 0;
-			currentByteRange = void 0;
-		}
-	}
-	const totalDuration = currentTime;
-	const initialization = unresolved.type === "text" && !initSegmentUrl ? void 0 : initSegmentUrl ? {
-		url: initSegmentUrl,
-		...initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}
-	} : { url: "" };
 	return {
-		...unresolved,
-		startTime: 0,
-		duration: totalDuration,
-		segments,
-		initialization
-	};
-}
-
-//#endregion
-//#region ../spf/dist/dev/core/utils/generate-id.js
-/**
-* Generate unique ID for HAM objects.
-*
-* Uses timestamp + random number for sufficient uniqueness.
-* IDs are strings without decimals.
-*
-* @returns Unique string ID in format: timestamp-random
-*
-* @example
-* ```ts
-* const id = generateId();  // "1738423156789-542891"
-* ```
-*/
-function generateId() {
-	return `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
-}
-
-//#endregion
-//#region ../spf/dist/dev/core/hls/parse-multivariant.js
-/**
-* 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")
-				});
+		send(message) {
+			if (destroyed) return;
+			const allTasks = planTasks(message);
+			if (!running) {
+				if (allTasks.length === 0) return;
+				runScheduled(allTasks);
+				return;
 			}
-			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;
+			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();
 			}
-		}
-		const track = {
-			type: "audio",
-			id: generateId(),
-			url: rendition.uri ?? "",
-			groupId: rendition.groupId,
-			name: rendition.name,
-			mimeType: "audio/mp4",
-			bandwidth: 0,
-			sampleRate: 48e3,
-			channels: 2,
-			codecs: []
-		};
-		if (rendition.language) track.language = rendition.language;
-		if (audioCodecs) track.codecs = audioCodecs;
-		if (rendition.default) track.default = rendition.default;
-		if (rendition.autoselect) track.autoselect = rendition.autoselect;
-		return track;
-	}), ...audioOnlyTracks];
-	const textTracks = subtitleRenditions.map((rendition) => {
-		const track = {
-			type: "text",
-			id: generateId(),
-			url: rendition.uri,
-			groupId: rendition.groupId,
-			label: rendition.name,
-			kind: "subtitles",
-			mimeType: "text/vtt",
-			bandwidth: 0
-		};
-		if (rendition.language) track.language = rendition.language;
-		if (rendition.default && rendition.autoselect) track.default = true;
-		if (rendition.autoselect) track.autoselect = rendition.autoselect;
-		if (rendition.forced) track.forced = rendition.forced;
-		return track;
-	});
-	const selectionSets = [];
-	if (videoTracks.length > 0) {
-		const videoSwitchingSet = {
-			id: generateId(),
-			type: "video",
-			tracks: videoTracks
-		};
-		const videoSelectionSet = {
-			id: generateId(),
-			type: "video",
-			switchingSets: [videoSwitchingSet]
-		};
-		selectionSets.push(videoSelectionSet);
-	}
-	if (audioTracks.length > 0) {
-		const audioSwitchingSet = {
-			id: generateId(),
-			type: "audio",
-			tracks: audioTracks
-		};
-		const audioSelectionSet = {
-			id: generateId(),
-			type: "audio",
-			switchingSets: [audioSwitchingSet]
-		};
-		selectionSets.push(audioSelectionSet);
-	}
-	if (textTracks.length > 0) {
-		const textSwitchingSet = {
-			id: generateId(),
-			type: "text",
-			tracks: textTracks
-		};
-		const textSelectionSet = {
-			id: generateId(),
-			type: "text",
-			switchingSets: [textSwitchingSet]
-		};
-		selectionSets.push(textSelectionSet);
-	}
-	return {
-		id: generateId(),
-		url: unresolved.url,
-		startTime: 0,
-		selectionSets
-	};
-}
-
-//#endregion
-//#region ../spf/dist/dev/core/abr/quality-selection.js
-/**
-* Default quality selection configuration.
-* Values match Shaka Player upgrade threshold (0.85 = 15% headroom).
-*/
-const DEFAULT_QUALITY_CONFIG = { safetyMargin: .85 };
-/**
-* Select the best video track based on current bandwidth estimate.
-*
-* Selects the highest quality track where bandwidth is sufficient with safety margin:
-* - currentBandwidth >= track.bandwidth / safetyMargin
-* - Default safetyMargin 0.85 means track uses ≤85% of bandwidth (15% headroom)
-* - At same bandwidth, prefers higher resolution
-*
-* @param tracks - Available video tracks (can be unsorted)
-* @param currentBandwidth - Current bandwidth estimate in bits per second
-* @param config - Optional quality selection configuration
-* @returns Selected track, or undefined if no tracks available
-*
-* @example
-* const tracks = [
-*   { id: '360p', bandwidth: 500_000, ... },
-*   { id: '720p', bandwidth: 2_000_000, ... },
-*   { id: '1080p', bandwidth: 4_000_000, ... },
-* ];
-*
-* // With 2.5 Mbps, selects 720p (1080p needs 4M/0.85 = 4.7 Mbps)
-* const selected = selectQuality(tracks, 2_500_000);
-*/
-function selectQuality(tracks, currentBandwidth, config = DEFAULT_QUALITY_CONFIG) {
-	if (tracks.length === 0) return;
-	const sortedTracks = tracks.slice().sort((a, b) => a.bandwidth - b.bandwidth);
-	let chosen;
-	for (const track of sortedTracks) if (currentBandwidth >= track.bandwidth / config.safetyMargin) {
-		if (!chosen || track.bandwidth > chosen.bandwidth || track.bandwidth === chosen.bandwidth && hasHigherResolution(track, chosen)) chosen = track;
-	}
-	return chosen ?? sortedTracks[0];
-}
-/**
-* Check if track A has higher resolution than track B.
-* Compares by total pixel count (width × height).
-*
-* @param trackA - First track to compare
-* @param trackB - Second track to compare
-* @returns True if trackA has more pixels than trackB
-*/
-function hasHigherResolution(trackA, trackB) {
-	return (trackA.width ?? 0) * (trackA.height ?? 0) > (trackB.width ?? 0) * (trackB.height ?? 0);
-}
-
-//#endregion
-//#region ../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;
+		},
+		destroy() {
+			destroyed = true;
+			abortController?.abort();
+		}
+	};
 }
 
 //#endregion
-//#region ../spf/dist/dev/dom/media/mediasource-setup.js
-/**
-* 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";
+//#region ../spf/dist/dev/dom/features/load-segments.js
+const ActorKeyByType$1 = {
+	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.get(), elapsed, chunk.byteLength);
+				throughput.set(next);
+				onSample?.(next);
+				yield chunk;
+				chunkStart = performance.now();
+			}
+		} };
+	};
 }
 /**
-* Check if ManagedMediaSource API is supported.
-* ManagedMediaSource is a newer Safari API with better lifecycle management.
+* 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).
 */
-function supportsManagedMediaSource() {
-	return typeof ManagedMediaSource !== "undefined";
+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
+	};
 }
 /**
-* Create a MediaSource or ManagedMediaSource instance.
+* Equality function encoding the condition hierarchy for relevant changes.
 *
-* @param options - Creation options
-* @returns A MediaSource or ManagedMediaSource instance
-* @throws Error if no MediaSource API is available
+* 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).
 *
-* @example
-* const mediaSource = createMediaSource();
-* const mediaElement = document.querySelector('video');
-* attachMediaSource(mediaSource, mediaElement);
+* 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.
 */
-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");
-}
+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;
+};
 /**
-* 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
+* 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.
 *
-* @example
-* const mediaSource = createMediaSource();
-* const { detach } = attachMediaSource(mediaSource, videoElement);
-* await waitForSourceOpen(mediaSource);
-* // Use mediaSource...
-* // Later, to clean up:
-* detach();
+* This IS the shouldLoadSegments logic, expressed as an equality function.
 */
-function attachMediaSource(mediaSource, mediaElement) {
-	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) {
-		mediaElement.disableRemotePlayback = true;
-		mediaElement.srcObject = mediaSource;
-		const detach = () => {
-			mediaElement.srcObject = null;
-			mediaElement.load();
-		};
-		return {
-			url: "",
-			detach
-		};
+function loadingInputsEq(prevState, curState) {
+	if (!curState.segmentsCanLoad) return true;
+	if (!curState.playbackInitiated) {
+		if (curState.preload === "none") return true;
+		return curState.preload === prevState.preload;
 	}
-	const url = URL.createObjectURL(mediaSource);
-	mediaElement.src = url;
-	const detach = () => {
-		mediaElement.removeAttribute("src");
-		mediaElement.load();
-		URL.revokeObjectURL(url);
-	};
-	return {
-		url,
-		detach
-	};
+	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);
 }
 /**
-* Wait for a MediaSource to reach the 'open' state.
-* Resolves immediately if already open.
+* 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.
 *
-* @param mediaSource - The MediaSource to wait for
-* @param signal - Optional AbortSignal for cancellation
-* @returns Promise that resolves when the MediaSource is open
+*   playbackInitiated
+*     resolvedTrackId changes      → trigger
+*     segmentStart(currentTime) changes → trigger (segment boundary only)
 *
 * @example
-* const mediaSource = createMediaSource();
-* attachMediaSource(mediaSource, videoElement);
-* await waitForSourceOpen(mediaSource);
-* // MediaSource is now ready for SourceBuffer creation
+* const cleanup = loadSegments({ state, owners }, { type: 'video' });
 */
-function waitForSourceOpen(mediaSource, signal) {
-	return new Promise((resolve, reject) => {
-		if (mediaSource.readyState === "open") {
-			resolve();
-			return;
+function loadSegments({ state, owners }, config) {
+	const { type } = config;
+	const actorKey = ActorKeyByType$1[type];
+	const initialBandwidth = state.get().bandwidthState;
+	const throughput = signal(initialBandwidth ?? {
+		fastEstimate: 0,
+		fastTotalWeight: 0,
+		slowEstimate: 0,
+		slowTotalWeight: 0,
+		bytesSampled: 0
+	});
+	const fetchBytes = type === "video" ? createTrackedFetch(throughput, initialBandwidth !== void 0 ? (next) => {
+		state.set(Object.assign({}, state.get(), { bandwidthState: next }));
+	} : void 0) : fetchStream;
+	const segmentLoader = signal(void 0);
+	const actorSource = computed(() => owners.get()[actorKey]);
+	let currentLoader;
+	const cleanupActorLifecycle = effect(() => {
+		const actor = actorSource.get();
+		if (currentLoader) {
+			currentLoader.destroy();
+			segmentLoader.set(void 0);
+			currentLoader = void 0;
 		}
-		if (signal?.aborted) {
-			reject(new DOMException("Aborted", "AbortError"));
-			return;
+		if (actor) {
+			const loader = createSegmentLoaderActor(actor, fetchBytes);
+			currentLoader = loader;
+			segmentLoader.set(loader);
 		}
-		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);
 	});
+	const segmentsCanLoad = computed(() => {
+		const track = getSelectedTrack(state.get(), type);
+		return !!track && isResolvedTrack(track) && !!segmentLoader.get();
+	});
+	const loadingInputs = computed(() => selectLoadingInputs([segmentsCanLoad.get(), state.get()], type));
+	let prevInputs;
+	const cleanupLoadEffect = effect(() => {
+		const inputs = loadingInputs.get();
+		if (prevInputs !== void 0 && loadingInputsEq(prevInputs, inputs)) return;
+		const { preload, playbackInitiated, currentTime, track, segmentsCanLoad: canLoad } = inputs;
+		if (!canLoad) return;
+		prevInputs = inputs;
+		if (!(preload === "auto" || !!playbackInitiated))
+ /** @ts-expect-error */
+		segmentLoader.get()?.send({
+			type: "load",
+			track
+		});
+		else segmentLoader.get()?.send({
+			type: "load",
+			track,
+			range: {
+				start: currentTime,
+				end: currentTime + DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration
+			}
+		});
+	});
+	return () => {
+		cleanupActorLifecycle();
+		cleanupLoadEffect();
+		currentLoader?.destroy();
+	};
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/text/parse-vtt-segment.js
 /**
-* 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
+* Parse a VTT segment using browser's native parser.
 *
-* @example
-* await waitForSourceOpen(mediaSource);
-* const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs="avc1.42E01E"');
+* Creates a dummy video element with a track element to leverage
+* the browser's optimized VTT parsing. Returns parsed VTTCue objects.
 */
-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);
+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;
+	});
 }
-/**
-* 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);
+function destroyVttParser() {
+	dummyVideo = null;
 }
 
 //#endregion
-//#region ../spf/dist/dev/core/events/create-event-stream.js
-/**
-* 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");
+//#region ../spf/dist/dev/dom/features/load-text-track-cues.js
+const CueKeys = [
+	"startTime",
+	"endTime",
+	"text"
+];
+function isDuplicateCue(cue, existingCues) {
+	return Array.prototype.some.call(existingCues ?? [], (existingCue) => {
+		return CueKeys.every((k) => existingCue[k] === cue[k]);
+	});
+}
+const loadVttSegmentTask = async ({ segment }, { textTrack }) => {
+	(await parseVttSegment(segment.url)).forEach((cue) => {
+		if (isDuplicateCue(cue, textTrack.cues)) return;
+		textTrack.addCue(cue);
+	});
+};
 /**
-* 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' });
-* ```
+* Load text track cues task (composite - orchestrates VTT segment subtasks).
 */
-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);
+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 latestState = context.state.get();
+			const latest = latestState.textBufferState ?? {};
+			const trackState = latest[trackId] ?? { segments: [] };
+			context.state.set({
+				...latestState,
+				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);
 		}
-	};
-}
-
-//#endregion
-//#region ../spf/dist/dev/core/features/resolve-presentation.js
+	}
+	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));
+};
 /**
-* Type guard to check if presentation is unresolved.
+* Find the selected text track in the presentation.
 */
-function isUnresolved(presentation) {
-	return presentation !== void 0 && "url" in presentation && !("id" in presentation);
-}
-function canResolve$1(state) {
-	return isUnresolved(state.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);
 }
 /**
-* Determines if resolution conditions are met based on preload policy and event.
+* Get the browser's TextTrack object for the selected text track.
 *
-* Resolution conditions:
-* - State-driven: preload is 'auto' or 'metadata'
-* - Event-driven: play event
+* Retrieves the live TextTrack interface from the track element in owners,
+* which is used for adding cues, checking mode, and managing track state.
 *
-* @param state - Current presentation state
-* @param event - Current action/event
-* @returns true if resolution conditions are met
+* 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 shouldResolve$1(state, event) {
-	const { preload } = state;
-	return ["auto", "metadata"].includes(preload) || event.type === "play";
+function getSelectedTextTrackFromOwners(state, owners) {
+	const trackId = state.selectedTextTrackId;
+	if (!trackId || !owners.textTracks) return;
+	return owners.textTracks.get(trackId)?.track;
 }
 /**
-* Syncs preload attribute from mediaElement to state.
+* Check if we can load text track cues.
 *
-* Watches the owners state for mediaElement changes and copies the
-* preload attribute to the immutable state.
+* 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.
 *
-* @param state - Immutable state container
-* @param owners - Mutable platform objects container
-* @returns Cleanup function to stop syncing
+* Only load if:
+* - Track is resolved (has segments)
+* - Track has at least one segment
+* - Track element exists
 */
-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 });
-	});
+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;
 }
 /**
-* Resolves unresolved presentations using reactive composition.
+* Load text track cues orchestration.
 *
-* Uses combineLatest to compose state + events, enabling both state-driven
-* and event-driven resolution triggers.
+* Triggers when:
+* - Text track is selected
+* - Track is resolved (has segments)
+* - Track element exists
 *
-* Triggers resolution when:
-* - State-driven: Unresolved presentation + preload allows (auto/metadata)
-* - Event-driven: PLAY event when preload="none"
+* 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
-* ```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' });
-* ```
+* const cleanup = loadTextTrackCues({ state, owners });
 */
-function resolvePresentation({ state, events }) {
-	let resolving = false;
+function loadTextTrackCues({ state, owners }) {
+	let currentTask = null;
 	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;
+	let lastTrackId;
+	const selectedTrackId = computed(() => state.get().selectedTextTrackId);
+	const cleanupEffect = effect(() => {
+		const s = state.get();
+		const o = owners.get();
+		if (selectedTrackId.get() !== lastTrackId) {
+			lastTrackId = selectedTrackId.get();
+			abortController?.abort();
+			currentTask = null;
 		}
+		if (currentTask) return;
+		if (!shouldLoadTextTrackCues(s, o)) return;
+		const textTrack = getSelectedTextTrackFromOwners(s, o);
+		if (!textTrack) return;
+		abortController = new AbortController();
+		currentTask = loadTextTrackCuesTask({ currentState: s }, {
+			signal: abortController.signal,
+			textTrack,
+			state
+		}).finally(() => {
+			currentTask = null;
+		});
 	});
 	return () => {
 		abortController?.abort();
-		cleanup();
+		cleanupEffect();
 	};
 }
 
 //#endregion
-//#region ../spf/dist/dev/core/features/quality-switching.js
-/**
-* 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 ?? [];
-}
+//#region ../spf/dist/dev/dom/features/track-current-time.js
 /**
-* Quality switching orchestration (F9).
-*
-* Reacts to bandwidth estimate changes and updates `selectedVideoTrackId`
-* when a different quality is optimal:
+* Track current playback position from the media element.
 *
-* - **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.
+* 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.
 *
-* 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.
+* Also syncs immediately when a media element becomes available.
 *
 * @example
-* const cleanup = switchQuality({ state });
-* // Later, when done:
-* cleanup();
+* const cleanup = trackCurrentTime({ state, owners });
 */
-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 });
+function trackCurrentTime({ state, owners }) {
+	let lastMediaElement;
+	let removeListeners = null;
+	const cleanupEffect = effect(() => {
+		const { mediaElement } = owners.get();
+		if (mediaElement === lastMediaElement) return;
+		removeListeners?.();
+		removeListeners = null;
+		lastMediaElement = mediaElement;
+		if (!mediaElement) return;
+		const sync = () => {
+			update(state, { currentTime: mediaElement.currentTime });
+		};
+		sync();
+		const removeTimeupdate = listen(mediaElement, "timeupdate", sync);
+		const removeSeeking = listen(mediaElement, "seeking", sync);
+		removeListeners = () => {
+			removeTimeupdate();
+			removeSeeking();
+		};
 	});
+	return () => {
+		removeListeners?.();
+		cleanupEffect();
+	};
 }
 
 //#endregion
-//#region ../spf/dist/dev/core/utils/track-selection.js
-/**
-* Map track type to selected track ID property key in state.
-*/
-const SelectedTrackIdKeyByType = {
-	video: "selectedVideoTrackId",
-	audio: "selectedAudioTrackId",
-	text: "selectedTextTrackId"
-};
+//#region ../spf/dist/dev/dom/features/track-playback-initiated.js
 /**
-* 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.
+* Track whether playback has been initiated for the current presentation URL.
+*
+* Uses a local intermediate signal written by two effect streams:
+* - false stream: resets on URL change
+* - true stream: sets on play event
+*
+* A third merge effect reads the local signal and writes to state, reading
+* `state.get()` at merge time so the spread uses the up-to-date value after
+* the async forward bridge has run.
 *
 * @example
-* const videoTrack = getSelectedTrack(state, 'video');
-* if (videoTrack && isResolvedTrack(videoTrack)) {
-*   // videoTrack is VideoTrack
-* }
+* const cleanup = trackPlaybackInitiated({ state, owners, events });
 */
-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);
+function trackPlaybackInitiated({ state, owners }) {
+	const presentationUrl = computed(() => state.get().presentation?.url);
+	const mediaElement = computed(() => owners.get().mediaElement);
+	const playbackInitiated = signal(void 0);
+	let lastPresentationUrl;
+	let lastMediaElement;
+	const cleanupResetEffect = effect(() => {
+		const url = presentationUrl.get();
+		const el = mediaElement.get();
+		if (url !== lastPresentationUrl && lastPresentationUrl !== void 0 || el !== lastMediaElement && lastMediaElement !== void 0) playbackInitiated.set(false);
+		lastPresentationUrl = url;
+		lastMediaElement = el;
+	});
+	const cleanupPlayEffect = effect(() => {
+		const el = mediaElement.get();
+		if (!el) return;
+		return listen(el, "play", () => {
+			playbackInitiated.set(true);
+		});
+	});
+	const cleanupMergeEffect = effect(() => {
+		const pi = playbackInitiated.get();
+		if (pi === void 0) return;
+		if (state.get().playbackInitiated !== pi) update(state, { playbackInitiated: pi });
+	});
+	return () => {
+		cleanupResetEffect();
+		cleanupPlayEffect();
+		cleanupMergeEffect();
+	};
 }
 
 //#endregion
-//#region ../spf/dist/dev/dom/features/segment-loader-actor.js
+//#region ../spf/dist/dev/dom/media/append-segment.js
 /**
-* 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.
+* Append media data to a SourceBuffer.
 *
-* 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.
+* 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.
 *
-* @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.
+* Errors from the SourceBuffer (`error` event) or from the iterable are
+* propagated as rejections.
 */
-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 }
-			});
+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);
 		}
-		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;
+	} 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 {
-			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;
+			sourceBuffer.appendBuffer(data);
+		} catch (error) {
+			cleanup();
+			reject(error);
 		}
-		abortController = null;
-		running = false;
-	};
-	return {
-		send(message) {
-			if (destroyed) return;
-			const allTasks = planTasks(message);
-			if (!running) {
-				if (allTasks.length === 0) return;
-				runScheduled(allTasks);
-				return;
-			}
-			if (inFlightSegmentId !== null && allTasks.some((t) => t.type === "append-segment" && t.meta.id === inFlightSegmentId) || inFlightInitTrackId !== null && allTasks.some((t) => t.type === "append-init" && t.meta.trackId === inFlightInitTrackId)) pendingTasks = allTasks.filter((t) => !(t.type === "append-segment" && t.meta.id === inFlightSegmentId) && !(t.type === "append-init" && t.meta.trackId === inFlightInitTrackId));
-			else {
-				pendingTasks = allTasks;
-				abortController?.abort();
-			}
-		},
-		destroy() {
-			destroyed = true;
-			abortController?.abort();
+	});
+}
+
+//#endregion
+//#region ../spf/dist/dev/dom/media/buffer-flusher.js
+/**
+* Buffer flusher helper (P12)
+*
+* Removes a time range from a SourceBuffer to manage memory.
+*/
+/**
+* Remove a time range from a SourceBuffer.
+*
+* Waits for the SourceBuffer to be ready (not updating), then removes
+* the specified range. Returns a promise that resolves when removal completes.
+*
+* @param sourceBuffer - The SourceBuffer to remove data from
+* @param start - Start of the time range to remove (seconds)
+* @param end - End of the time range to remove (seconds)
+* @returns Promise that resolves when removal completes
+*
+* @example
+* await flushBuffer(videoSourceBuffer, 0, 30);
+*/
+async function flushBuffer(sourceBuffer, start, end) {
+	if (sourceBuffer.updating) await new Promise((resolve) => {
+		const onUpdateEnd = () => {
+			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
+			resolve();
+		};
+		sourceBuffer.addEventListener("updateend", onUpdateEnd);
+	});
+	return new Promise((resolve, reject) => {
+		const onUpdateEnd = () => {
+			cleanup();
+			resolve();
+		};
+		const onError = (event) => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`SourceBuffer remove error: ${event.type}`));
+		};
+		const cleanup = () => {
+			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
+			sourceBuffer.removeEventListener("error", onError);
+		};
+		sourceBuffer.addEventListener("updateend", onUpdateEnd);
+		sourceBuffer.addEventListener("error", onError);
+		try {
+			sourceBuffer.remove(start, end);
+		} catch (error) {
+			cleanup();
+			reject(error);
 		}
-	};
+	});
 }
 
 //#endregion
-//#region ../spf/dist/dev/dom/features/load-segments.js
-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();
-			}
-		} };
-	};
+//#region ../spf/dist/dev/core/features/calculate-presentation-duration.js
+/**
+* Check if we can calculate presentation duration (have required data).
+*/
+function canCalculateDuration(state) {
+	if (!state.presentation) return false;
+	return !!(state.selectedVideoTrackId || state.selectedAudioTrackId);
 }
 /**
-* 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).
+* Check if we should calculate presentation duration (conditions met).
 */
-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 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));
 }
-function selectLoadingInputs([segmentsCanLoad, state], type) {
-	const { playbackInitiated, preload, currentTime } = state;
-	return {
-		playbackInitiated,
-		preload,
-		currentTime,
-		track: getSelectedTrack(state, type),
-		segmentsCanLoad
-	};
+/**
+* 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;
 }
 /**
-* Equality function encoding the condition hierarchy for relevant changes.
+* Calculate and set presentation duration from resolved tracks.
+*/
+function calculatePresentationDuration({ state }) {
+	return effect(() => {
+		const currentState = state.get();
+		if (!shouldCalculateDuration(currentState)) return;
+		const duration = getDurationFromResolvedTracks(currentState);
+		if (duration === void 0 || !Number.isFinite(duration)) return;
+		state.set({
+			...currentState,
+			presentation: {
+				...currentState.presentation,
+				duration
+			}
+		});
+	});
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/abr/quality-selection.js
+/**
+* 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.
 *
-* 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).
+* 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
 *
-* playbackInitiated transition:
-*   Always fires (handled in the subscriber; preload='auto' suppression
-*   applied there since equality functions have no memory of prior values).
+* @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
 *
-* 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.
+* @example
+* const tracks = [
+*   { id: '360p', bandwidth: 500_000, ... },
+*   { id: '720p', bandwidth: 2_000_000, ... },
+*   { id: '1080p', bandwidth: 4_000_000, ... },
+* ];
 *
-* This IS the shouldLoadSegments logic, expressed as an equality function.
+* // With 2.5 Mbps, selects 720p (1080p needs 4M/0.85 = 4.7 Mbps)
+* const selected = selectQuality(tracks, 2_500_000);
 */
-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;
+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;
 	}
-	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);
+	return chosen ?? sortedTracks[0];
 }
 /**
-* 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.
+* Check if track A has higher resolution than track B.
+* Compares by total pixel count (width × height).
 *
-* Condition hierarchy (see SegmentLoadingKey for detail):
+* @param trackA - First track to compare
+* @param trackB - Second track to compare
+* @returns True if trackA has more pixels than trackB
+*/
+function hasHigherResolution(trackA, trackB) {
+	return (trackA.width ?? 0) * (trackA.height ?? 0) > (trackB.width ?? 0) * (trackB.height ?? 0);
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/features/quality-switching.js
+/**
+* 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).
 *
-*   !playbackInitiated
-*     preload==='none' (or unset)  → dormant; no trigger
-*     preload==='metadata'         → trigger on transition to 'metadata'
-*     preload==='auto'             → trigger on transition to 'auto'
+* Reacts to bandwidth estimate changes and updates `selectedVideoTrackId`
+* when a different quality is optimal:
 *
-*   !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.
+* - **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.
 *
-*   playbackInitiated
-*     resolvedTrackId changes      → trigger
-*     segmentStart(currentTime) changes → trigger (segment boundary only)
+* 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 = loadSegments({ state, owners }, { type: 'video' });
+* const cleanup = switchQuality({ state });
+* // Later, when done:
+* cleanup();
 */
-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);
+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 effect(() => {
+		const { presentation, bandwidthState, selectedVideoTrackId, abrDisabled } = state.get();
+		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;
 		}
-		return () => {
-			segmentLoader.current?.destroy();
-			segmentLoader.patch(void 0);
-		};
+		update(state, { selectedVideoTrackId: optimal.id });
 	});
-	const segmentsCanLoad = createState(false);
-	const unsubscribeCanLoadSegments = combineLatest([state, segmentLoader]).subscribe(([currentState, currentSegmentLoader]) => {
-		const track = getSelectedTrack(currentState, type);
-		const trackResolved = !!track && isResolvedTrack(track);
-		const segmentLoaderActorExists = !!currentSegmentLoader;
-		segmentsCanLoad.patch(trackResolved && segmentLoaderActorExists);
-	});
-	const unsubscribeShouldLoadSegments = combineLatest([segmentsCanLoad, state]).subscribe(([segmentsCanLoad, state]) => selectLoadingInputs([segmentsCanLoad, state], type), ({ preload, playbackInitiated, currentTime, track }) => {
-		if (!(preload === "auto" || !!playbackInitiated))
- /** @ts-expect-error */
-		segmentLoader.current?.send({
-			type: "load",
-			track
-		});
-		else segmentLoader.current?.send({
-			type: "load",
-			track,
-			range: {
-				start: currentTime,
-				end: currentTime + DEFAULT_FORWARD_BUFFER_CONFIG.bufferDuration
-			}
-		});
-	}, { equalityFn: loadingInputsEq });
-	return () => {
-		unsubscribeCanLoadSegments();
-		unsubscribeShouldLoadSegments();
-		unsubActorLifecycle();
-	};
 }
 
 //#endregion
-//#region ../spf/dist/dev/dom/text/parse-vtt-segment.js
+//#region ../spf/dist/dev/core/utils/generate-id.js
 /**
-* Parse a VTT segment using browser's native parser.
+* Generate unique ID for HAM objects.
 *
-* Creates a dummy video element with a track element to leverage
-* the browser's optimized VTT parsing. Returns parsed VTTCue 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"
+* ```
 */
-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 generateId() {
+	return `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
 }
 
 //#endregion
-//#region ../spf/dist/dev/dom/features/load-text-track-cues.js
-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;
+//#region ../spf/dist/dev/core/hls/parse-attributes.js
+/**
+* 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 false;
+	return attributes;
 }
-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).
+* Parse RESOLUTION attribute value (WIDTHxHEIGHT).
 */
-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));
-};
+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)
+	};
+}
 /**
-* Find the selected text track in the presentation.
+* Parse FRAME-RATE attribute to rational frame rate.
 */
-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);
+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) };
 }
 /**
-* 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
+* Parse CODECS attribute into separate video and audio codecs.
 */
-function getSelectedTextTrackFromOwners(state, owners) {
-	const trackId = state.selectedTextTrackId;
-	if (!trackId || !owners.textTracks) return;
-	return owners.textTracks.get(trackId)?.track;
+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;
 }
 /**
-* Check if we can load text track cues.
-*
-* Requires:
-* - Selected text track ID exists
-* - Track elements map exists
-* - Track element exists for selected track
+* 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 canLoadTextTrackCues(state, owners) {
-	return !!state.selectedTextTrackId && !!owners.textTracks && owners.textTracks.has(state.selectedTextTrackId);
+function matchTag(line, tag) {
+	const prefix = `#${tag}:`;
+	if (!line.startsWith(prefix)) return null;
+	return createAttributeList(line.slice(prefix.length));
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/hls/resolve-url.js
 /**
-* 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
+* Resolve a potentially relative URL against a base URL using native URL API.
 */
-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;
+function resolveUrl(url, baseUrl) {
+	return new URL(url, baseUrl).href;
 }
+
+//#endregion
+//#region ../spf/dist/dev/core/hls/parse-multivariant.js
 /**
-* Load text track cues orchestration.
-*
-* Triggers when:
-* - Text track is selected
-* - Track is resolved (has segments)
-* - Track element exists
+* Parse HLS multivariant playlist into a Presentation.
 *
-* 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.
+* 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.
 *
-* @example
-* const cleanup = loadTextTrackCues({ state, owners });
+* @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 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;
+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;
 		}
-		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;
-		});
+		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;
 	});
-	return () => {
-		abortController?.abort();
-		cleanup();
+	const audioOnlyTracks = audioOnlyStreams.map((stream) => {
+		const codecs = stream.codecs ? parseCodecs(stream.codecs) : void 0;
+		return {
+			type: "audio",
+			id: generateId(),
+			url: stream.uri,
+			bandwidth: stream.bandwidth,
+			mimeType: "audio/mp4",
+			codecs: codecs?.audio ? [codecs.audio] : [],
+			groupId: stream.audioGroupId || "default",
+			name: "Default",
+			sampleRate: 48e3,
+			channels: 2
+		};
+	});
+	const audioTracks = [...audioRenditions.map((rendition) => {
+		let audioCodecs;
+		for (const stream of streams) if (stream.audioGroupId === rendition.groupId && stream.codecs) {
+			const codecs = parseCodecs(stream.codecs);
+			if (codecs.audio) {
+				audioCodecs = [codecs.audio];
+				break;
+			}
+		}
+		const track = {
+			type: "audio",
+			id: generateId(),
+			url: rendition.uri ?? "",
+			groupId: rendition.groupId,
+			name: rendition.name,
+			mimeType: "audio/mp4",
+			bandwidth: 0,
+			sampleRate: 48e3,
+			channels: 2,
+			codecs: []
+		};
+		if (rendition.language) track.language = rendition.language;
+		if (audioCodecs) track.codecs = audioCodecs;
+		if (rendition.default) track.default = rendition.default;
+		if (rendition.autoselect) track.autoselect = rendition.autoselect;
+		return track;
+	}), ...audioOnlyTracks];
+	const textTracks = subtitleRenditions.map((rendition) => {
+		const track = {
+			type: "text",
+			id: generateId(),
+			url: rendition.uri,
+			groupId: rendition.groupId,
+			label: rendition.name,
+			kind: "subtitles",
+			mimeType: "text/vtt",
+			bandwidth: 0
+		};
+		if (rendition.language) track.language = rendition.language;
+		if (rendition.default && rendition.autoselect) track.default = true;
+		if (rendition.autoselect) track.autoselect = rendition.autoselect;
+		if (rendition.forced) track.forced = rendition.forced;
+		return track;
+	});
+	const selectionSets = [];
+	if (videoTracks.length > 0) {
+		const videoSwitchingSet = {
+			id: generateId(),
+			type: "video",
+			tracks: videoTracks
+		};
+		const videoSelectionSet = {
+			id: generateId(),
+			type: "video",
+			switchingSets: [videoSwitchingSet]
+		};
+		selectionSets.push(videoSelectionSet);
+	}
+	if (audioTracks.length > 0) {
+		const audioSwitchingSet = {
+			id: generateId(),
+			type: "audio",
+			tracks: audioTracks
+		};
+		const audioSelectionSet = {
+			id: generateId(),
+			type: "audio",
+			switchingSets: [audioSwitchingSet]
+		};
+		selectionSets.push(audioSelectionSet);
+	}
+	if (textTracks.length > 0) {
+		const textSwitchingSet = {
+			id: generateId(),
+			type: "text",
+			tracks: textTracks
+		};
+		const textSelectionSet = {
+			id: generateId(),
+			type: "text",
+			switchingSets: [textSwitchingSet]
+		};
+		selectionSets.push(textSelectionSet);
+	}
+	return {
+		id: generateId(),
+		url: unresolved.url,
+		startTime: 0,
+		selectionSets
 	};
 }
 
 //#endregion
-//#region ../spf/dist/dev/dom/features/track-current-time.js
+//#region ../spf/dist/dev/core/features/resolve-presentation.js
 /**
-* 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.
+* 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 playback state.
 *
-* Also syncs immediately when a media element becomes available.
+* Resolution conditions:
+* - State-driven: preload is 'auto' or 'metadata'
+* - Playback-driven: playbackInitiated is true
 *
-* @example
-* const cleanup = trackCurrentTime({ state, owners });
+* @param state - Current presentation state
+* @returns true if resolution conditions are met
 */
-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();
-	};
+function shouldResolve(state) {
+	const { preload, playbackInitiated } = state;
+	return ["auto", "metadata"].includes(preload) || !!playbackInitiated;
 }
-
-//#endregion
-//#region ../spf/dist/dev/dom/features/track-playback-initiated.js
 /**
-* Track whether playback has been initiated by the user.
+* Resolves unresolved presentations using reactive composition.
+*
+* Triggers resolution when:
+* - State-driven: Unresolved presentation + preload allows (auto/metadata)
+* - Playback-driven: playbackInitiated is true
 *
-* 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.
+* @example
+* ```ts
+* const state = signal({ presentation: undefined, preload: 'auto', playbackInitiated: false });
 *
-* Resets `state.playbackInitiated = false` when `presentation.url` changes,
-* so a new source with `preload="none"` won't load segments until play is
-* triggered again.
+* const cleanup = resolvePresentation({ state });
 *
-* 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.
+* // State-driven: resolves immediately when preload allows
+* state.set({ ...state.get(), presentation: { url: 'http://example.com/playlist.m3u8' } });
 *
-* @example
-* const cleanup = trackPlaybackInitiated({ state, owners, events });
+* // Playback-driven: resolves when playbackInitiated is set
+* state.set({ ...state.get(), preload: 'none', presentation: { url: '...' }, playbackInitiated: true });
+* ```
 */
-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" });
+function resolvePresentation({ state }) {
+	const canResolveSignal = computed(() => canResolve$1(state.get()));
+	const shouldResolveSignal = computed(() => shouldResolve(state.get()));
+	let resolving = false;
+	let abortController = null;
+	const cleanupEffect = effect(() => {
+		if (!canResolveSignal.get() || !shouldResolveSignal.get() || resolving) return;
+		const presentation = state.get().presentation;
+		resolving = true;
+		abortController = new AbortController();
+		fetchResolvable(presentation, { signal: abortController.signal }).then((response) => getResponseText(response)).then((text) => {
+			update(state, { presentation: parseMultivariantPlaylist(text, presentation) });
+		}).catch((error) => {
+			if (error instanceof Error && error.name === "AbortError") return;
+			throw error;
+		}).finally(() => {
+			resolving = false;
+			abortController = null;
 		});
 	});
 	return () => {
-		removeListener?.();
-		unsubscribeState();
-		unsubscribeOwners();
+		abortController?.abort();
+		cleanupEffect();
 	};
 }
 
 //#endregion
-//#region ../spf/dist/dev/dom/media/append-segment.js
+//#region ../spf/dist/dev/core/hls/parse-media-playlist.js
 /**
-* Append media data to a SourceBuffer.
+* Parse HLS media playlist and resolve track with segments.
 *
-* 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.
+* Takes an unresolved track (from multivariant playlist) and media playlist text,
+* returns a HAM-compliant resolved track with segments.
 *
-* Errors from the SourceBuffer (`error` event) or from the iterable are
-* propagated as rejections.
+* @param text - Media playlist text content
+* @param unresolved - Unresolved track from parseMultivariantPlaylist
+* @returns Resolved track with segments (type inferred from input)
 */
-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);
+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;
 		}
-	});
-}
-
-//#endregion
-//#region ../spf/dist/dev/dom/media/buffer-flusher.js
-/**
-* 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);
+		if (trimmed.startsWith("#EXTINF:")) {
+			currentDuration = parseExtInfDuration(trimmed.slice(8));
+			continue;
 		}
-	});
-}
-
-//#endregion
-//#region ../spf/dist/dev/core/features/calculate-presentation-duration.js
-/**
-* 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
-		} });
-	});
+		if (trimmed.startsWith("#EXT-X-BYTERANGE:")) {
+			currentByteRange = parseByteRange(trimmed.slice(17), previousByteRangeEnd) ?? void 0;
+			continue;
+		}
+		if (trimmed === "#EXT-X-ENDLIST") continue;
+		if (!trimmed.startsWith("#") && currentDuration > 0) {
+			const segment = {
+				id: `segment-${segmentIndex}`,
+				url: resolveUrl(trimmed, baseUrl),
+				duration: currentDuration,
+				startTime: currentTime
+			};
+			if (currentByteRange) {
+				segment.byteRange = currentByteRange;
+				previousByteRangeEnd = currentByteRange.end + 1;
+			} else previousByteRangeEnd = void 0;
+			segments.push(segment);
+			currentTime += currentDuration;
+			segmentIndex++;
+			currentDuration = 0;
+			currentByteRange = void 0;
+		}
+	}
+	const totalDuration = currentTime;
+	const initialization = unresolved.type === "text" && !initSegmentUrl ? void 0 : initSegmentUrl ? {
+		url: initSegmentUrl,
+		...initSegmentByteRange ? { byteRange: initSegmentByteRange } : {}
+	} : { url: "" };
+	return {
+		...unresolved,
+		startTime: 0,
+		duration: totalDuration,
+		segments,
+		initialization
+	};
 }
 
 //#endregion
@@ -2324,7 +2471,7 @@ var Task = class {
 		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;
+		this.#signal = config?.signal ? anyAbortSignal([this.#abortController.signal, config.signal]) : this.#abortController.signal;
 	}
 	get status() {
 		return this.#status;
@@ -2424,19 +2571,6 @@ function canResolve(state, config) {
 	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.
 */
@@ -2456,26 +2590,29 @@ function updateTrackInPresentation(presentation, resolvedTrack) {
 /**
 * 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.
+* Reacts to state changes and schedules fetch tasks via ConcurrentRunner when
+* a selected track is unresolved. The ConcurrentRunner handles 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) {
+function resolveTrack({ state }, config) {
 	const runner = new ConcurrentRunner();
-	const cleanup = combineLatest([state, events]).subscribe(([currentState, event]) => {
-		if (!canResolve(currentState, config) || !shouldResolve(currentState, event)) return;
+	const cleanup = effect(() => {
+		const currentState = state.get();
+		if (!canResolve(currentState, config)) 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 });
+			const latest = state.get();
+			const updatedPresentation = updateTrackInPresentation(latest.presentation, mediaTrack);
+			state.set({
+				...latest,
+				presentation: updatedPresentation
+			});
 		}, { id: track.id }));
 	});
 	return () => {
@@ -2558,19 +2695,11 @@ function shouldSelectTrack(state, config) {
 * );
 */
 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;
-		}
+	return effect(() => {
+		const currentState = state.get();
+		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
+		const selectedTrackId = currentState.presentation?.selectionSets.find(({ type }) => type === config.type)?.switchingSets[0]?.tracks[0]?.id;
+		if (selectedTrackId) update(state, { [SelectedTrackIdKeyByType[config.type]]: selectedTrackId });
 	});
 }
 /**
@@ -2589,16 +2718,11 @@ function selectVideoTrack({ state }, config = { type: "video" }) {
 * );
 */
 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;
-		}
+	return effect(() => {
+		const currentState = state.get();
+		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
+		const selectedTrackId = currentState.presentation?.selectionSets.find(({ type }) => type === "audio")?.switchingSets[0]?.tracks[0]?.id;
+		if (selectedTrackId) update(state, { selectedAudioTrackId: selectedTrackId });
 	});
 }
 /**
@@ -2614,16 +2738,33 @@ function selectAudioTrack({ state }, config = { type: "audio" }) {
 * 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;
-		}
+	return effect(() => {
+		const currentState = state.get();
+		if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
+		const selectedTextTrackId = pickTextTrack(currentState.presentation, config);
+		if (selectedTextTrackId) update(state, { selectedTextTrackId });
+	});
+}
+
+//#endregion
+//#region ../spf/dist/dev/core/features/sync-preload-attribute.js
+/**
+* Syncs preload attribute from mediaElement to state.
+*
+* Watches the owners signal for mediaElement changes and copies the
+* preload attribute to state when no explicit value has been set.
+* An explicit value (set via SpfMedia.preload) always wins.
+*
+* @example
+* const cleanup = syncPreloadAttribute({ state, owners });
+*/
+function syncPreloadAttribute({ state, owners }) {
+	const mediaElement = computed(() => owners.get().mediaElement);
+	return effect(() => {
+		if (state.get().preload !== void 0) return;
+		const preload = mediaElement.get()?.preload || void 0;
+		if (preload === void 0) return;
+		update(state, { preload });
 	});
 }
 
@@ -2640,7 +2781,7 @@ 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;
+	return actor?.snapshot.get().context.segments.some((s) => s.id === lastSeg.id && !s.partial) ?? false;
 }
 /**
 * Check if the last segment has been appended for each selected track.
@@ -2672,15 +2813,15 @@ function canEndStream(state, owners) {
 */
 function shouldEndStream(state, owners) {
 	if (!canEndStream(state, owners)) return false;
-	const { mediaSource, mediaElement } = owners;
-	if (mediaSource.readyState !== "open") return false;
+	const { mediaElement } = owners;
+	if ((owners.mediaSourceReadyState?.get() ?? owners.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 (owners.videoBufferActor?.snapshot.get().status === "updating") return false;
+	if (owners.audioBufferActor?.snapshot.get().status === "updating") return false;
 	if (!hasLastSegmentLoaded(state, owners)) return false;
 	if (mediaElement) {
 		const videoTrack = hasVideoTrack ? getSelectedTrack(state, "video") : void 0;
@@ -2699,13 +2840,18 @@ function shouldEndStream(state, owners) {
 * 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");
+	const updatingActors = [owners.videoBufferActor, owners.audioBufferActor].filter((actor) => actor !== void 0 && actor.snapshot.get().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();
+		let cleanup;
+		let resolved = false;
+		cleanup = effect(() => {
+			if (actor.snapshot.get().status !== "updating") {
+				if (!resolved) {
+					resolved = true;
+					resolve();
+				}
+				queueMicrotask(() => cleanup?.());
 			}
 		});
 	}))).then(() => void 0);
@@ -2747,64 +2893,165 @@ const endOfStreamTask = async ({ currentOwners }, _context) => {
 * and MediaSource.duration updates.
 */
 function endOfStream({ state, owners }) {
+	const shouldEnd = computed(() => shouldEndStream(state.get(), owners.get()));
 	let hasEnded = false;
-	let destroyed = false;
-	const activeActorUnsubs = [];
-	const runEvaluate = async () => {
-		if (destroyed) return;
-		const currentState = state.current;
-		const currentOwners = owners.current;
+	return effect(() => {
+		if (!shouldEnd.get()) return;
+		const currentOwners = owners.get();
 		if (hasEnded) {
-			if (currentOwners.mediaSource?.readyState !== "open") return;
+			if ((currentOwners.mediaSourceReadyState?.get() ?? 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();
-			}));
-		}
+		endOfStreamTask({ currentOwners }, {}).catch((error) => console.error("Failed to call endOfStream:", error));
 	});
-	const cleanupCombineLatest = combineLatest([state, owners]).subscribe(async () => runEvaluate());
-	return () => {
-		destroyed = true;
-		activeActorUnsubs.forEach((u) => u());
-		cleanupOwners();
-		cleanupCombineLatest();
-	};
 }
 
 //#endregion
-//#region ../spf/dist/dev/dom/features/setup-mediasource.js
+//#region ../spf/dist/dev/dom/media/mediasource-setup.js
+/**
+* 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);
+* // Use mediaSource...
+* // Later, to clean up:
+* detach();
+*/
+function attachMediaSource(mediaSource, mediaElement) {
+	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) {
+		mediaElement.disableRemotePlayback = true;
+		mediaElement.srcObject = mediaSource;
+		const detach = () => {
+			mediaElement.srcObject = null;
+			mediaElement.load();
+		};
+		return {
+			url: "",
+			detach
+		};
+	}
+	const url = URL.createObjectURL(mediaSource);
+	mediaElement.src = url;
+	const detach = () => {
+		mediaElement.removeAttribute("src");
+		mediaElement.load();
+		URL.revokeObjectURL(url);
+	};
+	return {
+		url,
+		detach
+	};
+}
 /**
-* Check if we have the minimum requirements to create MediaSource.
+* 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
+* const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs="avc1.42E01E"');
 */
-function canSetup(state, owners) {
-	return !isNil(owners.mediaElement) && !isNil(state.presentation?.url);
+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 we should proceed with MediaSource creation.
-* Placeholder for future conditions (e.g., checking if already created).
+* 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 shouldSetup(_state, owners) {
-	return isNil(owners.mediaSource);
+function isCodecSupported(mimeCodec) {
+	if (!supportsMediaSource()) return false;
+	return MediaSource.isTypeSupported(mimeCodec);
+}
+/**
+* Create a reactive signal that mirrors `mediaSource.readyState`.
+*
+* Listens to `sourceopen`, `sourceended`, and `sourceclose` events and updates
+* the signal accordingly, making readyState visible to the TC39 signal graph.
+* Listeners are automatically removed when `signal` is aborted.
+*
+* @param mediaSource - The MediaSource to observe
+* @param signal - AbortSignal that controls listener lifetime
+* @returns A `Signal.ReadonlyState` that reflects the current `readyState`
+*
+* @example
+* const controller = new AbortController();
+* const readyState = observeMediaSourceReadyState(mediaSource, controller.signal);
+* effect(() => {
+*   if (readyState.get() === 'open') { ... }
+* });
+* // Later:
+* controller.abort();
+*/
+function observeMediaSourceReadyState(mediaSource, abortSignal) {
+	const readyState = signal(mediaSource.readyState);
+	const update = () => readyState.set(mediaSource.readyState);
+	const options = { signal: abortSignal };
+	mediaSource.addEventListener("sourceopen", update, options);
+	mediaSource.addEventListener("sourceended", update, options);
+	mediaSource.addEventListener("sourceclose", update, options);
+	return readyState;
 }
+
+//#endregion
+//#region ../spf/dist/dev/dom/features/setup-mediasource.js
 /**
 * Setup MediaSource orchestration.
 *
@@ -2815,27 +3062,34 @@ function shouldSetup(_state, owners) {
 * 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;
-		}
+	const abortController = new AbortController();
+	const mediaElementSignal = computed(() => owners.get().mediaElement);
+	const presentationUrlSignal = computed(() => state.get().presentation?.url);
+	const canSetupSignal = computed(() => !!mediaElementSignal.get() && !!presentationUrlSignal.get());
+	const mediaElementSrcSignal = computed(() => mediaElementSignal.get()?.src);
+	const mediaSourceSignal = computed(() => owners.get().mediaSource);
+	const shouldSetupSignal = computed(() => !mediaElementSrcSignal.get());
+	const cleanupEffect = effect(() => {
+		if (!canSetupSignal.get() || !shouldSetupSignal.get()) return;
+		const mediaElement = mediaElementSignal.get();
+		const { signal } = abortController;
+		const mediaSource = createMediaSource({ preferManaged: true });
+		const mediaSourceReadyState = observeMediaSourceReadyState(mediaSource, signal);
+		attachMediaSource(mediaSource, mediaElement);
+		const cleanupOwnersUpdateEffect = effect(() => {
+			if (!!mediaSourceSignal.get() || mediaSourceReadyState.get() !== "open") return;
+			owners.set(Object.assign({}, owners.get(), {
+				mediaSource,
+				mediaSourceReadyState
+			}));
+		});
+		return () => {
+			cleanupOwnersUpdateEffect();
+		};
 	});
 	return () => {
 		abortController?.abort();
-		unsubscribe();
+		cleanupEffect();
 	};
 }
 
@@ -2930,7 +3184,7 @@ function messageToTask(message, options) {
 	return factory(message, options);
 }
 function createSourceBufferActor(sourceBuffer, initialContext) {
-	const state = createState({
+	const snapshotSignal = signal({
 		status: "idle",
 		context: {
 			segments: [],
@@ -2941,55 +3195,47 @@ function createSourceBufferActor(sourceBuffer, initialContext) {
 	});
 	const runner = new SerialRunner();
 	function applyResult(newContext) {
-		const status = state.current.status === "destroyed" ? "destroyed" : "idle";
-		state.patch({
+		const status = snapshotSignal.get().status === "destroyed" ? "destroyed" : "idle";
+		snapshotSignal.set({
 			status,
 			context: newContext
 		});
-		state.flush();
 	}
 	function handleError(e) {
-		const status = state.current.status === "destroyed" ? "destroyed" : "idle";
-		state.patch({ status });
-		state.flush();
+		update(snapshotSignal, { status: snapshotSignal.get().status === "destroyed" ? "destroyed" : "idle" });
 		throw e;
 	}
 	return {
 		get snapshot() {
-			return state.current;
-		},
-		subscribe(listener) {
-			return state.subscribe(listener);
+			return snapshotSignal;
 		},
 		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" });
+			if (snapshotSignal.get().status !== "idle") return Promise.reject(new SourceBufferActorError(`send() called while actor is ${snapshotSignal.get().status}`));
+			update(snapshotSignal, { status: "updating" });
 			const onPartialContext = (ctx) => {
-				state.patch({
+				snapshotSignal.set({
 					status: "updating",
 					context: ctx
 				});
-				state.flush();
 			};
 			const task = messageToTask(message, {
 				signal,
-				getCtx: () => state.current.context,
+				getCtx: () => snapshotSignal.get().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 (snapshotSignal.get().status !== "idle") return Promise.reject(new SourceBufferActorError(`batch() called while actor is ${snapshotSignal.get().status}`));
 			if (messages.length === 0) return Promise.resolve();
-			state.patch({ status: "updating" });
-			let workingCtx = state.current.context;
+			update(snapshotSignal, { status: "updating" });
+			let workingCtx = snapshotSignal.get().context;
 			const onPartialContext = (ctx) => {
-				state.patch({
+				snapshotSignal.set({
 					status: "updating",
 					context: ctx
 				});
-				state.flush();
 			};
 			for (const message of messages.slice(0, -1)) {
 				const task = messageToTask(message, {
@@ -3011,8 +3257,7 @@ function createSourceBufferActor(sourceBuffer, initialContext) {
 			return runner.schedule(lastTask).then(applyResult).catch(handleError);
 		},
 		destroy() {
-			state.patch({ status: "destroyed" });
-			state.flush();
+			update(snapshotSignal, { status: "destroyed" });
 			runner.destroy();
 		}
 	};
@@ -3020,6 +3265,10 @@ function createSourceBufferActor(sourceBuffer, initialContext) {
 
 //#endregion
 //#region ../spf/dist/dev/dom/features/setup-sourcebuffer.js
+const ActorKeyByType = {
+	video: "videoBufferActor",
+	audio: "audioBufferActor"
+};
 /**
 * Build MIME codec string from track metadata.
 *
@@ -3037,76 +3286,56 @@ function buildMimeCodec(track) {
 /**
 * 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.
+* Waits until ALL media tracks in the presentation are resolved with codecs,
+* then creates every SourceBuffer in one synchronous block before setting
+* owners. This guarantees that downstream consumers (e.g. loadSegments) never
+* see a partial set of SourceBuffers — preventing the Firefox bug where
+* appending to a video SourceBuffer before the audio SourceBuffer exists
+* causes mozHasAudio to be permanently false.
 *
 * Handles video-only, audio-only, and combined presentations correctly:
-* only the tracks that are actually selected are waited on and created.
+* track types are derived from the presentation rather than hardcoded.
 *
 * @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 presentationTypesSignal = computed(() => {
+		const { presentation } = state.get();
+		if (!presentation || !("selectionSets" in presentation)) return [];
+		return presentation.selectionSets.map(({ type }) => type).filter((type) => type === "video" || type === "audio");
+	});
+	const canSetupSignal = computed(() => {
+		const types = presentationTypesSignal.get();
+		if (!owners.get().mediaSource || types.length === 0) return false;
+		const s = state.get();
+		return types.every((type) => {
+			const track = getSelectedTrack(s, type);
+			return track && isResolvedTrack(track) && !!track.codecs?.length;
+		});
+	});
+	const shouldSetupSignal = computed(() => {
+		const o = owners.get();
+		return presentationTypesSignal.get().every((type) => !o[BufferKeyByType[type]]);
+	});
+	return effect(() => {
+		if (!canSetupSignal.get() || !shouldSetupSignal.get()) return;
+		const s = state.get();
+		const o = owners.get();
 		const patch = {};
-		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);
+		for (const type of presentationTypesSignal.get()) {
+			const track = getSelectedTrack(s, type);
+			const buffer = createSourceBuffer(o.mediaSource, buildMimeCodec(track));
+			patch[BufferKeyByType[type]] = buffer;
+			patch[ActorKeyByType[type]] = createSourceBufferActor(buffer);
 		}
-		owners.patch(patch);
-		await new Promise((resolve) => requestAnimationFrame(resolve));
+		update(owners, patch);
 	});
 }
 
 //#endregion
 //#region ../spf/dist/dev/dom/features/setup-text-tracks.js
 /**
-* 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
@@ -3139,27 +3368,31 @@ function createTrackElement(track) {
 * 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 modelTextTracksSignal = computed(() => state.get().presentation?.selectionSets?.find((selectionSet) => selectionSet.type === "text")?.switchingSets[0]?.tracks, { equals(prevTextTracks, nextTextTracks) {
+		if (prevTextTracks === nextTextTracks) return true;
+		if (typeof prevTextTracks !== typeof nextTextTracks) return false;
+		if (prevTextTracks?.length !== nextTextTracks?.length) return false;
+		return !!nextTextTracks && nextTextTracks.every((nextTextTrack) => prevTextTracks?.some((prevTextTrack) => prevTextTrack.id === nextTextTrack.id));
+	} });
+	const ownerTextTracksSignal = computed(() => owners.get().textTracks);
+	const mediaElementSignal = computed(() => owners.get().mediaElement);
+	const canSetupTextTracksSignal = computed(() => !!mediaElementSignal.get() && modelTextTracksSignal.get()?.length);
+	const shouldSetupTextTracksSignal = computed(() => !ownerTextTracksSignal.get());
+	const cleanupEffect = effect(() => {
+		if (!canSetupTextTracksSignal.get() || !shouldSetupTextTracksSignal.get()) return;
+		const mediaElement = mediaElementSignal.get();
+		const modelTextTracks = modelTextTracksSignal.get();
 		const trackMap = /* @__PURE__ */ new Map();
-		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 });
+		modelTextTracks.forEach((modelTextTrack) => {
+			const trackElement = createTrackElement(modelTextTrack);
+			mediaElement.appendChild(trackElement);
+			trackMap.set(modelTextTrack.id, trackElement);
+		});
+		if (trackMap.size) update(owners, { textTracks: trackMap });
 	});
 	return () => {
-		for (const trackElement of createdTracks) trackElement.remove();
-		createdTracks = [];
-		unsubscribe();
+		owners.get().textTracks?.forEach((trackElement) => trackElement.remove());
+		cleanupEffect();
 	};
 }
 
@@ -3188,52 +3421,33 @@ function setupTextTracks({ state, owners }) {
 * 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;
+	const mediaElement = computed(() => owners.get().mediaElement);
+	return effect(() => {
+		const el = mediaElement.get();
+		if (!el) return;
+		return listen(el.textTracks, "change", () => {
+			const newId = Array.from(el.textTracks).find((t) => t.mode === "showing" && (t.kind === "subtitles" || t.kind === "captions"))?.id || void 0;
+			const current = state.get();
 			if (current.selectedTextTrackId === newId) return;
-			if (newId) state.patch({ selectedTextTrackId: newId });
+			if (newId) update(state, { selectedTextTrackId: newId });
 			else {
 				const prevId = current.selectedTextTrackId;
 				if (prevId && current.textBufferState?.[prevId]) {
 					const next = { ...current.textBufferState };
 					delete next[prevId];
-					state.patch({
+					update(state, {
 						selectedTextTrackId: void 0,
 						textBufferState: next
 					});
-				} else state.patch({ selectedTextTrackId: void 0 });
+				} else update(state, { selectedTextTrackId: void 0 });
 			}
-		};
-		removeListener = listen(mediaElement.textTracks, "change", sync);
+		});
 	});
-	return () => {
-		removeListener?.();
-		unsubscribe();
-	};
 }
 
 //#endregion
 //#region ../spf/dist/dev/dom/features/sync-text-track-modes.js
 /**
-* 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:
@@ -3248,11 +3462,15 @@ function canSyncTextTrackModes(owners) {
 * 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";
+	const textTracksSignal = computed(() => owners.get().textTracks);
+	const selectedTextTrackIdSignal = computed(() => state.get().selectedTextTrackId);
+	const canSyncTextTrackModes = computed(() => !!textTracksSignal.get()?.size);
+	return effect(() => {
+		if (!canSyncTextTrackModes.get()) return;
+		/** @TODO refactor TextTracks owners model. Should simply use id. Also should use corresponding TextTrack (JS) element if possible (CJP) */
+		const textTracks = textTracksSignal.get();
+		const selectedTextTrackId = selectedTextTrackIdSignal.get();
+		for (const [trackId, trackElement] of textTracks) trackElement.track.mode = trackId === selectedTextTrackId ? "showing" : "hidden";
 	});
 }
 
@@ -3286,7 +3504,7 @@ function shouldUpdateDuration(state, owners) {
 	if (!canUpdateDuration(state, owners)) return false;
 	const { mediaSource } = owners;
 	const { presentation } = state;
-	if (mediaSource.readyState !== "open") return false;
+	if ((owners.mediaSourceReadyState?.get() ?? owners.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);
@@ -3307,19 +3525,26 @@ function waitForSourceBuffersReady(owners) {
 */
 function updateDuration({ state, owners }) {
 	let destroyed = false;
-	const unsubscribe = combineLatest([state, owners]).subscribe(async ([currentState, currentOwners]) => {
-		if (!shouldUpdateDuration(currentState, currentOwners)) return;
+	let running = false;
+	const cleanupEffect = effect(() => {
+		const currentState = state.get();
+		const currentOwners = owners.get();
+		if (!shouldUpdateDuration(currentState, currentOwners) || running) 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;
+		running = true;
+		waitForSourceBuffersReady(currentOwners).then(() => {
+			if (destroyed || mediaSource.readyState !== "open") return;
+			let duration = currentState.presentation.duration;
+			const maxBufferedEnd = getMaxBufferedEnd(currentOwners);
+			if (maxBufferedEnd > duration) duration = maxBufferedEnd;
+			mediaSource.duration = duration;
+		}).finally(() => {
+			running = false;
+		});
 	});
 	return () => {
 		destroyed = true;
-		unsubscribe();
+		cleanupEffect();
 	};
 }
 
@@ -3346,78 +3571,56 @@ function updateDuration({ state, owners }) {
 *   preferredAudioLanguage: 'en',
 * });
 *
-* // Initialize by patching state and owners
-* engine.owners.patch({ mediaElement: document.querySelector('video') });
-* engine.state.patch({
+* // Initialize by setting state and owners
+* engine.owners.set({ ...engine.owners.get(), mediaElement: document.querySelector('video') });
+* engine.state.set({
+*   ...engine.state.get(),
 *   presentation: { url: 'https://example.com/playlist.m3u8' },
 *   preload: 'auto',
 * });
 *
 * // Inspect state
-* console.log(engine.state.current);
+* console.log(engine.state.get());
 *
 * // Cleanup
 * engine.destroy();
 */
 function createPlaybackEngine(config = {}) {
-	const state = createState({ bandwidthState: {
+	const state = signal({ bandwidthState: {
 		fastEstimate: 0,
 		fastTotalWeight: 0,
 		slowEstimate: 0,
 		slowTotalWeight: 0,
 		bytesSampled: 0
 	} });
-	const owners = createState({});
-	const events = createEventStream();
+	const owners = signal({});
 	const cleanups = [
-		syncPreloadAttribute(state, owners),
-		trackPlaybackInitiated({
+		syncPreloadAttribute({
 			state,
-			owners,
-			events
+			owners
 		}),
-		resolvePresentation({
+		trackPlaybackInitiated({
 			state,
-			events
+			owners
 		}),
-		selectVideoTrack({
-			state,
-			owners,
-			events
-		}, {
+		resolvePresentation({ state }),
+		selectVideoTrack({ state }, {
 			type: "video",
 			...config.initialBandwidth !== void 0 && { initialBandwidth: config.initialBandwidth }
 		}),
-		selectAudioTrack({
-			state,
-			owners,
-			events
-		}, {
+		selectAudioTrack({ state }, {
 			type: "audio",
 			...config.preferredAudioLanguage !== void 0 && { preferredAudioLanguage: config.preferredAudioLanguage }
 		}),
-		selectTextTrack({
-			state,
-			owners,
-			events
-		}, {
+		selectTextTrack({ state }, {
 			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" }),
+		resolveTrack({ state }, { type: "video" }),
+		resolveTrack({ state }, { type: "audio" }),
+		resolveTrack({ state }, { type: "text" }),
 		calculatePresentationDuration({ state }),
 		setupMediaSource({
 			state,
@@ -3435,7 +3638,7 @@ function createPlaybackEngine(config = {}) {
 			state,
 			owners
 		}),
-		switchQuality({ state }),
+		switchQuality({ state }, config.initialBandwidth !== void 0 ? { defaultBandwidth: config.initialBandwidth } : {}),
 		loadSegments({
 			state,
 			owners
@@ -3465,11 +3668,9 @@ function createPlaybackEngine(config = {}) {
 			owners
 		})
 	];
-	events.dispatch({ type: "@@INITIALIZE@@" });
 	return {
 		state,
 		owners,
-		events,
 		destroy: () => {
 			cleanups.forEach((cleanup) => cleanup());
 			destroyVttParser();
@@ -3515,11 +3716,11 @@ var SpfMedia = class {
 		return this.#engine;
 	}
 	attach(mediaElement) {
-		this.#engine.owners.patch({ mediaElement });
+		update(this.#engine.owners, { mediaElement });
 	}
 	detach() {
 		this.#cancelPendingPlay();
-		this.#engine.owners.patch({ mediaElement: void 0 });
+		update(this.#engine.owners, { mediaElement: void 0 });
 	}
 	destroy() {
 		this.#cancelPendingPlay();
@@ -3530,24 +3731,24 @@ var SpfMedia = class {
 	}
 	set preload(value) {
 		this.#preload = value;
-		if (value) this.#engine.state.patch({ preload: value });
+		if (value) update(this.#engine.state, { preload: value });
 	}
 	get src() {
-		return this.#engine.state.current.presentation?.url ?? "";
+		return this.#engine.state.get().presentation?.url ?? "";
 	}
 	set src(value) {
-		const prevMediaElement = this.#engine.owners.current.mediaElement;
+		const prevMediaElement = this.#engine.owners.get().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 } });
+		if (this.#preload) update(this.#engine.state, { preload: this.#preload });
+		if (prevMediaElement) update(this.#engine.owners, { mediaElement: prevMediaElement });
+		if (value) update(this.#engine.state, { presentation: { url: value } });
 	}
 	play() {
-		const { mediaElement } = this.#engine.owners.current;
+		const { mediaElement } = this.#engine.owners.get();
 		if (!mediaElement) return Promise.reject(/* @__PURE__ */ new Error("SpfMedia: no media element attached"));
-		this.#engine.state.patch({ playbackInitiated: true });
+		update(this.#engine.state, { playbackInitiated: true });
 		return mediaElement.play().catch((err) => {
 			if (this.src) return new Promise((resolve, reject) => {
 				const listener = () => {
@@ -3562,7 +3763,7 @@ var SpfMedia = class {
 	}
 	#cancelPendingPlay() {
 		if (!this.#loadstartListener) return;
-		const { mediaElement } = this.#engine.owners.current;
+		const { mediaElement } = this.#engine.owners.get();
 		mediaElement?.removeEventListener("loadstart", this.#loadstartListener);
 		this.#loadstartListener = null;
 	}
@@ -3570,24 +3771,15 @@ var SpfMedia = class {
 
 //#endregion
 //#region ../core/dist/dev/dom/media/simple-hls/index.js
-var SimpleHlsCustomMedia = class extends DelegateMixin(CustomMediaMixin(globalThis.HTMLElement ?? class {}, { tag: "video" }), SpfMedia) {};
+var SimpleHlsCustomMedia = class extends DelegateMixin(CustomVideoElement, 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);
-	}
+var SimpleHlsVideo = class extends MediaPropsMixin(MediaAttachMixin(SimpleHlsCustomMedia), SpfMedia) {
 	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
@@ -3597,7 +3789,7 @@ var SimpleHlsVideoElement = class extends SimpleHlsVideo {
 		this.tagName = "simple-hls-video";
 	}
 };
-customElements.define(SimpleHlsVideoElement.tagName, SimpleHlsVideoElement);
+safeDefine(SimpleHlsVideoElement);
 
 //#endregion
 //# sourceMappingURL=simple-hls-video.dev.js.map