@rivmux/runtime-worker 0.3.0 → 0.5.0

package/dist/rivmux-runtime-worker.js

@@ -1,15 +1,3 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
 //#region src/latency/buffer-ranges.ts
 function normalizeBufferedRanges(input) {
 	if (isBufferedRangeArray(input)) return input.filter(isValidRange).map((range) => ({
@@ -153,6 +141,111 @@ const PLAYBACK_RATE_RESTORE_THRESHOLD_SECONDS = .1;
 const SEEK_COOLDOWN_MS = 1e3;
 const SEEK_MIN_DELTA_SECONDS = .1;
 //#endregion
+//#region src/runtime/lifecycle.ts
+function raceLifecycleOperation(operation, signal, onLateValue) {
+	if (signal.aborted) {
+		operation.then(onLateValue, () => void 0);
+		return Promise.resolve({ cancelled: true });
+	}
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			operation.then(onLateValue, () => void 0);
+			resolve({ cancelled: true });
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		operation.then((value) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			resolve({
+				cancelled: false,
+				value
+			});
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+//#endregion
+//#region src/runtime/options.ts
+function mergeOptions(current, updates) {
+	return {
+		playback: {
+			...current.playback,
+			...updates.playback
+		},
+		latency: {
+			...current.latency,
+			...updates.latency
+		},
+		network: {
+			...current.network,
+			...updates.network,
+			headers: {
+				...current.network.headers,
+				...updates.network?.headers
+			},
+			retry: {
+				...current.network.retry,
+				...updates.network?.retry
+			}
+		},
+		runtime: {
+			...current.runtime,
+			...updates.runtime
+		},
+		diagnostics: {
+			...current.diagnostics,
+			...updates.diagnostics
+		}
+	};
+}
+//#endregion
+//#region src/runtime/stats.ts
+function updateAppendQueueHighWaterMark(current, mseStats) {
+	return {
+		length: Math.max(current.length, mseStats.appendQueueLength),
+		bytes: Math.max(current.bytes, mseStats.appendQueueBytes)
+	};
+}
+function getNetworkIdleMs(stats, nowMs) {
+	const markerMs = stats?.lastChunkAtMs ?? stats?.startedAtMs;
+	if (markerMs === void 0) return;
+	return Math.max(nowMs - markerMs, 0);
+}
+function createPlayerStats(snapshot) {
+	const { loaderStats, mseStats, latencyMetrics } = snapshot;
+	return {
+		bytesReceived: loaderStats?.bytesReceived ?? 0,
+		currentNetworkSpeed: loaderStats?.currentNetworkSpeed ?? 0,
+		networkIdleMs: getNetworkIdleMs(loaderStats, snapshot.nowMs),
+		outputBytes: snapshot.outputBytes,
+		appendQueueLength: mseStats.appendQueueLength,
+		appendQueueBytes: mseStats.appendQueueBytes,
+		appendQueueMaxLength: snapshot.appendQueueMaxLength,
+		appendQueueMaxBytes: snapshot.appendQueueMaxBytes,
+		loaderPaused: snapshot.loaderPaused,
+		sourceBufferUpdating: mseStats.sourceBufferUpdating,
+		sourceBufferCount: mseStats.sourceBufferCount,
+		bufferedStart: latencyMetrics.bufferedStart ?? mseStats.bufferedStart,
+		bufferedEnd: latencyMetrics.bufferedEnd ?? mseStats.bufferedEnd,
+		bufferedDuration: latencyMetrics.bufferedDuration ?? mseStats.bufferedDuration,
+		bufferedRangeCount: mseStats.bufferedRangeCount,
+		currentTime: latencyMetrics.currentTime,
+		liveLatency: latencyMetrics.liveLatency,
+		playbackRate: latencyMetrics.playbackRate,
+		readyState: latencyMetrics.readyState,
+		droppedFrames: latencyMetrics.droppedFrames
+	};
+}
+//#endregion
 //#region src/loader/retry-policy.ts
 function createRetryPolicy(input) {
 	return {
@@ -361,25 +454,25 @@ function createMp4VideoMime(codec) {
 function createMp4AudioMime(codec) {
 	return `audio/mp4; codecs="${codec}"`;
 }
-const REQUIRED_MSE_MIME_TYPES = [{
-	mediaType: "video",
-	mimeType: createMp4VideoMime("avc1.42C01E"),
-	unsupportedCode: "RIVMUX_UNSUPPORTED_MSE_VIDEO_MIME"
-}, {
-	mediaType: "audio",
-	mimeType: createMp4AudioMime("mp4a.40.2"),
-	unsupportedCode: "RIVMUX_UNSUPPORTED_MSE_AUDIO_MIME"
-}];
+var MseUnsupportedMimeError = class extends Error {
+	mimeType;
+	constructor(mimeType) {
+		super(`MSE does not support ${mimeType}.`);
+		this.name = "MseUnsupportedMimeError";
+		this.mimeType = mimeType;
+	}
+};
 function isMseSupported(mimeType) {
 	return typeof MediaSource !== "undefined" && typeof MediaSource.isTypeSupported === "function" && MediaSource.isTypeSupported(mimeType);
 }
-function assertMseSupport(mimeType) {
+function assertMseRuntimeSupport() {
 	if (typeof MediaSource === "undefined") throw new Error("MediaSource is not available in this worker.");
 	if (MediaSource.canConstructInDedicatedWorker !== true) throw new Error("MediaSource cannot be constructed in this dedicated worker.");
-	if (!isMseSupported(mimeType)) throw new Error(`MSE does not support ${mimeType}.`);
+	if (typeof MediaSource.isTypeSupported !== "function") throw new Error("MediaSource.isTypeSupported is not available in this worker.");
 }
-function assertRequiredMseSupport() {
-	for (const requirement of REQUIRED_MSE_MIME_TYPES) assertMseSupport(requirement.mimeType);
+function assertMseSupport(mimeType) {
+	assertMseRuntimeSupport();
+	if (!isMseSupported(mimeType)) throw new MseUnsupportedMimeError(mimeType);
 }
 //#endregion
 //#region src/mse/source-buffer-queue.ts
@@ -530,7 +623,7 @@ var MseController = class {
 		return Array.from(this.queues.values()).reduce((total, queue) => total + queue.bufferedRanges.length, 0);
 	}
 	async createMediaSourceHandle() {
-		assertRequiredMseSupport();
+		assertMseRuntimeSupport();
 		const mediaSource = new MediaSource();
 		this.mediaSource = mediaSource;
 		const handle = mediaSource.handle;
@@ -670,7 +763,7 @@ function coreWarningToPlayerWarning(warning) {
 	};
 }
 function normalizeCoreEvent(value) {
-	if (!isRecord$1(value) || typeof value.type !== "string") throw new TypeError("Transmux core event is missing a string type.");
+	if (!isRecord(value) || typeof value.type !== "string") throw new TypeError("Transmux core event is missing a string type.");
 	const data = value.data;
 	switch (value.type) {
 		case "probeResult": return {
@@ -689,10 +782,8 @@ function normalizeCoreEvent(value) {
 			type: "mediaSegment",
 			data: normalizeMediaSegment(data)
 		};
-		case "videoConfig":
-		case "audioConfig":
-		case "videoSample":
-		case "audioSample":
+		case "trackConfig":
+		case "sample":
 		case "metadata":
 		case "discontinuity": return {
 			type: value.type,
@@ -710,7 +801,7 @@ function normalizeCoreEvent(value) {
 	}
 }
 function normalizeInitSegment(value) {
-	if (!isRecord$1(value)) throw new TypeError("Transmux core initSegment event payload must be an object.");
+	if (!isRecord(value)) throw new TypeError("Transmux core initSegment event payload must be an object.");
 	return {
 		track: normalizeTrackKind(value.track),
 		codec: normalizeRequiredPrimitive(value.codec, "string", "initSegment codec"),
@@ -719,7 +810,7 @@ function normalizeInitSegment(value) {
 	};
 }
 function normalizeMediaSegment(value) {
-	if (!isRecord$1(value)) throw new TypeError("Transmux core mediaSegment event payload must be an object.");
+	if (!isRecord(value)) throw new TypeError("Transmux core mediaSegment event payload must be an object.");
 	return {
 		track: normalizeTrackKind(value.track),
 		dtsStartMs: normalizeRequiredPrimitive(value.dtsStartMs, "number", "mediaSegment dtsStartMs"),
@@ -729,7 +820,7 @@ function normalizeMediaSegment(value) {
 	};
 }
 function normalizeProbeResult(value) {
-	if (!isRecord$1(value) || value.container !== "flv" && value.container !== "mpegts") throw new TypeError("Transmux core probe result has an unsupported container.");
+	if (!isRecord(value) || value.container !== "flv" && value.container !== "mpegts") throw new TypeError("Transmux core probe result has an unsupported container.");
 	const result = { container: value.container };
 	const video = normalizeOptionalString(value.video, [
 		"avc",
@@ -748,7 +839,7 @@ function normalizeProbeResult(value) {
 	return result;
 }
 function normalizeMediaInfo(value) {
-	if (!isRecord$1(value)) throw new TypeError("Transmux core mediaInfo event payload must be an object.");
+	if (!isRecord(value)) throw new TypeError("Transmux core mediaInfo event payload must be an object.");
 	const result = { ...normalizeProbeResult(value) };
 	const videoCodec = normalizeOptionalPrimitive(value.videoCodec, "string");
 	const audioCodec = normalizeOptionalPrimitive(value.audioCodec, "string");
@@ -765,14 +856,14 @@ function normalizeMediaInfo(value) {
 	return result;
 }
 function normalizeWarning(value) {
-	if (!isRecord$1(value) || typeof value.code !== "string" || typeof value.message !== "string") throw new TypeError("Transmux core warning payload must include code and message.");
+	if (!isRecord(value) || typeof value.code !== "string" || typeof value.message !== "string") throw new TypeError("Transmux core warning payload must include code and message.");
 	return {
 		code: value.code,
 		message: value.message
 	};
 }
 function normalizeError(value) {
-	if (!isRecord$1(value) || typeof value.code !== "string" || typeof value.message !== "string") throw new TypeError("Transmux core error payload must include code and message.");
+	if (!isRecord(value) || typeof value.code !== "string" || typeof value.message !== "string") throw new TypeError("Transmux core error payload must include code and message.");
 	return {
 		code: normalizeCoreErrorCode(value.code),
 		message: value.message
@@ -829,29 +920,11 @@ function normalizeBytes(value, field) {
 	if (Array.isArray(value) && value.every((entry) => Number.isInteger(entry) && entry >= 0 && entry <= 255)) return new Uint8Array(value);
 	throw new TypeError(`Expected ${field} to be Uint8Array-compatible bytes.`);
 }
-function isRecord$1(value) {
+function isRecord(value) {
 	return typeof value === "object" && value !== null;
 }
 //#endregion
-//#region \0wasm-helpers.js
-function instantiate(source, imports, stream) {
-	const instantiate = WebAssembly[stream ? "instantiateStreaming" : "instantiate"];
-	return instantiate(source, imports).then(({ instance }) => instance);
-}
-function loadWasmModule(sync, fileUrl, src, imports) {
-	let buf = null;
-	if (fileUrl) return instantiate(fetch(fileUrl), imports, true);
-	const raw = globalThis.atob(src);
-	const len = raw.length;
-	buf = new Uint8Array(new ArrayBuffer(len));
-	for (let i = 0; i < len; i++) buf[i] = raw.charCodeAt(i);
-	if (sync) {
-		const mod = new WebAssembly.Module(buf);
-		return new WebAssembly.Instance(mod, imports);
-	} else return instantiate(buf, imports);
-}
-//#endregion
-//#region ../../crates/transmux-core/dist/rivmux_transmux_core_bg.js
+//#region ../../crates/transmux-core/dist/rivmux_transmux_core.js
 var TransmuxCore = class {
 	__destroy_into_raw() {
 		const ptr = this.__wbg_ptr;
@@ -870,16 +943,9 @@ var TransmuxCore = class {
 	* @returns {any}
 	*/
 	flush() {
-		try {
-			const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-			wasm.transmuxcore_flush(retptr, this.__wbg_ptr);
-			var r0 = getDataViewMemory0().getInt32(retptr + 0, true);
-			var r1 = getDataViewMemory0().getInt32(retptr + 4, true);
-			if (getDataViewMemory0().getInt32(retptr + 8, true)) throw takeObject(r1);
-			return takeObject(r0);
-		} finally {
-			wasm.__wbindgen_add_to_stack_pointer(16);
-		}
+		const ret = wasm.transmuxcore_flush(this.__wbg_ptr);
+		if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+		return takeFromExternrefTable0(ret[0]);
 	}
 	constructor() {
 		const ret = wasm.transmuxcore_new();
@@ -892,79 +958,74 @@ var TransmuxCore = class {
 	* @returns {any}
 	*/
 	pushChunk(data) {
-		try {
-			const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-			const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
-			const len0 = WASM_VECTOR_LEN;
-			wasm.transmuxcore_pushChunk(retptr, this.__wbg_ptr, ptr0, len0);
-			var r0 = getDataViewMemory0().getInt32(retptr + 0, true);
-			var r1 = getDataViewMemory0().getInt32(retptr + 4, true);
-			if (getDataViewMemory0().getInt32(retptr + 8, true)) throw takeObject(r1);
-			return takeObject(r0);
-		} finally {
-			wasm.__wbindgen_add_to_stack_pointer(16);
-		}
+		const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+		const len0 = WASM_VECTOR_LEN;
+		const ret = wasm.transmuxcore_pushChunk(this.__wbg_ptr, ptr0, len0);
+		if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+		return takeFromExternrefTable0(ret[0]);
 	}
 	reset() {
 		wasm.transmuxcore_reset(this.__wbg_ptr);
 	}
 };
 if (Symbol.dispose) TransmuxCore.prototype[Symbol.dispose] = TransmuxCore.prototype.free;
-function __wbg_Error_fdd633d4bb5dd76a(arg0, arg1) {
-	return addHeapObject(Error(getStringFromWasm0(arg0, arg1)));
-}
-function __wbg_String_8564e559799eccda(arg0, arg1) {
-	const ptr1 = passStringToWasm0(String(getObject(arg1)), wasm.__wbindgen_export, wasm.__wbindgen_export2);
-	const len1 = WASM_VECTOR_LEN;
-	getDataViewMemory0().setInt32(arg0 + 4, len1, true);
-	getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
-}
-function __wbg___wbindgen_throw_ea4887a5f8f9a9db(arg0, arg1) {
-	throw new Error(getStringFromWasm0(arg0, arg1));
-}
-function __wbg_new_2e117a478906f062() {
-	return addHeapObject(/* @__PURE__ */ new Object());
-}
-function __wbg_new_36e147a8ced3c6e0() {
-	return addHeapObject(new Array());
-}
-function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
-	getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
-}
-function __wbg_set_dc601f4a69da0bc2(arg0, arg1, arg2) {
-	getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-}
-function __wbindgen_cast_0000000000000001(arg0) {
-	return addHeapObject(arg0);
-}
-function __wbindgen_cast_0000000000000002(arg0) {
-	return addHeapObject(arg0);
-}
-function __wbindgen_cast_0000000000000003(arg0, arg1) {
-	return addHeapObject(getStringFromWasm0(arg0, arg1));
-}
-function __wbindgen_object_clone_ref(arg0) {
-	return addHeapObject(getObject(arg0));
-}
-function __wbindgen_object_drop_ref(arg0) {
-	takeObject(arg0);
+function __wbg_get_imports() {
+	return {
+		__proto__: null,
+		"./rivmux_transmux_core_bg.js": {
+			__proto__: null,
+			__wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
+				return Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbg_Number_c4bdf66bb78f7977: function(arg0) {
+				return Number(arg0);
+			},
+			__wbg_String_8564e559799eccda: function(arg0, arg1) {
+				const ptr1 = passStringToWasm0(String(arg1), wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+				const len1 = WASM_VECTOR_LEN;
+				getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+				getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+			},
+			__wbg___wbindgen_throw_ea4887a5f8f9a9db: function(arg0, arg1) {
+				throw new Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbg_new_2e117a478906f062: function() {
+				return /* @__PURE__ */ new Object();
+			},
+			__wbg_new_36e147a8ced3c6e0: function() {
+				return new Array();
+			},
+			__wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+				arg0[arg1] = arg2;
+			},
+			__wbg_set_dc601f4a69da0bc2: function(arg0, arg1, arg2) {
+				arg0[arg1 >>> 0] = arg2;
+			},
+			__wbindgen_cast_0000000000000001: function(arg0) {
+				return arg0;
+			},
+			__wbindgen_cast_0000000000000002: function(arg0) {
+				return arg0;
+			},
+			__wbindgen_cast_0000000000000003: function(arg0, arg1) {
+				return getStringFromWasm0(arg0, arg1);
+			},
+			__wbindgen_init_externref_table: function() {
+				const table = wasm.__wbindgen_externrefs;
+				const offset = table.grow(4);
+				table.set(0, void 0);
+				table.set(offset + 0, void 0);
+				table.set(offset + 1, null);
+				table.set(offset + 2, true);
+				table.set(offset + 3, false);
+			}
+		}
+	};
 }
 const TransmuxCoreFinalization = typeof FinalizationRegistry === "undefined" ? {
 	register: () => {},
 	unregister: () => {}
 } : new FinalizationRegistry((ptr) => wasm.__wbg_transmuxcore_free(ptr, 1));
-function addHeapObject(obj) {
-	if (heap_next === heap.length) heap.push(heap.length + 1);
-	const idx = heap_next;
-	heap_next = heap[idx];
-	heap[idx] = obj;
-	return idx;
-}
-function dropObject(idx) {
-	if (idx < 1028) return;
-	heap[idx] = heap_next;
-	heap_next = idx;
-}
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
 	if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
@@ -978,12 +1039,6 @@ function getUint8ArrayMemory0() {
 	if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
 	return cachedUint8ArrayMemory0;
 }
-function getObject(idx) {
-	return heap[idx];
-}
-let heap = new Array(1024).fill(void 0);
-heap.push(void 0, null, true, false);
-let heap_next = heap.length;
 function passArray8ToWasm0(arg, malloc) {
 	const ptr = malloc(arg.length * 1, 1) >>> 0;
 	getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -1018,10 +1073,10 @@ function passStringToWasm0(arg, malloc, realloc) {
 	WASM_VECTOR_LEN = offset;
 	return ptr;
 }
-function takeObject(idx) {
-	const ret = getObject(idx);
-	dropObject(idx);
-	return ret;
+function takeFromExternrefTable0(idx) {
+	const value = wasm.__wbindgen_externrefs.get(idx);
+	wasm.__externref_table_dealloc(idx);
+	return value;
 }
 let cachedTextDecoder = new TextDecoder("utf-8", {
 	ignoreBOM: true,
@@ -1053,123 +1108,534 @@ if (!("encodeInto" in cachedTextEncoder)) cachedTextEncoder.encodeInto = functio
 };
 let WASM_VECTOR_LEN = 0;
 let wasm;
-function __wbg_set_wasm(val) {
-	wasm = val;
+function __wbg_finalize_init(instance, module) {
+	wasm = instance.exports;
+	cachedDataViewMemory0 = null;
+	cachedUint8ArrayMemory0 = null;
+	wasm.__wbindgen_start();
+	return wasm;
+}
+async function __wbg_load(module, imports) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") try {
+			return await WebAssembly.instantiateStreaming(module, imports);
+		} catch (e) {
+			if (module.ok && expectedResponseType(module.type) && module.headers.get("Content-Type") !== "application/wasm") console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+			else throw e;
+		}
+		const bytes = await module.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module, imports);
+		if (instance instanceof WebAssembly.Instance) return {
+			instance,
+			module
+		};
+		else return instance;
+	}
+	function expectedResponseType(type) {
+		switch (type) {
+			case "basic":
+			case "cors":
+			case "default": return true;
+		}
+		return false;
+	}
+}
+async function __wbg_init(module_or_path) {
+	if (wasm !== void 0) return wasm;
+	if (module_or_path !== void 0) if (Object.getPrototypeOf(module_or_path) === Object.prototype) ({module_or_path} = module_or_path);
+	else console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+	if (module_or_path === void 0) module_or_path = new URL("rivmux_transmux_core_bg.wasm", import.meta.url);
+	const imports = __wbg_get_imports();
+	if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) module_or_path = fetch(module_or_path);
+	const { instance, module } = await __wbg_load(await module_or_path, imports);
+	return __wbg_finalize_init(instance, module);
 }
-//#endregion
-//#region ../../crates/transmux-core/dist/rivmux_transmux_core_bg.wasm
-var rivmux_transmux_core_bg_exports = /* @__PURE__ */ __exportAll({
-	__abort_handler: () => __abort_handler,
-	__instance_terminated: () => __instance_terminated,
-	__wbg_transmuxcore_free: () => __wbg_transmuxcore_free,
-	__wbindgen_add_to_stack_pointer: () => __wbindgen_add_to_stack_pointer,
-	__wbindgen_export: () => __wbindgen_export,
-	__wbindgen_export2: () => __wbindgen_export2,
-	memory: () => memory,
-	transmuxcore_destroy: () => transmuxcore_destroy,
-	transmuxcore_flush: () => transmuxcore_flush,
-	transmuxcore_new: () => transmuxcore_new,
-	transmuxcore_pushChunk: () => transmuxcore_pushChunk,
-	transmuxcore_reset: () => transmuxcore_reset
-});
-function __wasm_init(imports) {
-	return loadWasmModule(false, new URL("rivmux-transmux-core.wasm", import.meta.url), null, imports);
-}
-const instance = await __wasm_init({ "./rivmux_transmux_core_bg.js": {
-	"__wbindgen_object_drop_ref": __wbindgen_object_drop_ref,
-	"__wbg_set_dc601f4a69da0bc2": __wbg_set_dc601f4a69da0bc2,
-	"__wbg_set_6be42768c690e380": __wbg_set_6be42768c690e380,
-	"__wbindgen_object_clone_ref": __wbindgen_object_clone_ref,
-	"__wbg_String_8564e559799eccda": __wbg_String_8564e559799eccda,
-	"__wbg_new_36e147a8ced3c6e0": __wbg_new_36e147a8ced3c6e0,
-	"__wbg_new_2e117a478906f062": __wbg_new_2e117a478906f062,
-	"__wbg___wbindgen_throw_ea4887a5f8f9a9db": __wbg___wbindgen_throw_ea4887a5f8f9a9db,
-	"__wbg_Error_fdd633d4bb5dd76a": __wbg_Error_fdd633d4bb5dd76a,
-	"__wbindgen_cast_0000000000000001": __wbindgen_cast_0000000000000001,
-	"__wbindgen_cast_0000000000000002": __wbindgen_cast_0000000000000002,
-	"__wbindgen_cast_0000000000000003": __wbindgen_cast_0000000000000003
-} });
-const memory = instance.exports.memory;
-const __wbg_transmuxcore_free = instance.exports.__wbg_transmuxcore_free;
-const transmuxcore_destroy = instance.exports.transmuxcore_destroy;
-const transmuxcore_flush = instance.exports.transmuxcore_flush;
-const transmuxcore_new = instance.exports.transmuxcore_new;
-const transmuxcore_pushChunk = instance.exports.transmuxcore_pushChunk;
-const transmuxcore_reset = instance.exports.transmuxcore_reset;
-const __abort_handler = instance.exports.__abort_handler;
-const __instance_terminated = instance.exports.__instance_terminated;
-const __wbindgen_export = instance.exports.__wbindgen_export;
-const __wbindgen_export2 = instance.exports.__wbindgen_export2;
-const __wbindgen_add_to_stack_pointer = instance.exports.__wbindgen_add_to_stack_pointer;
-//#endregion
-//#region ../../crates/transmux-core/dist/rivmux_transmux_core.js
-__wbg_set_wasm(rivmux_transmux_core_bg_exports);
 //#endregion
 //#region src/wasm/wasm-loader.ts
 function createWasmTransmuxCoreHost(Core) {
 	if (Core === void 0) throw new TypeError("WASM transmux core constructor is not available.");
 	return new WasmTransmuxCoreHost(Core);
 }
-function createBundledWasmTransmuxCoreHost() {
-	return createWasmTransmuxCoreHost(TransmuxCore);
-}
 async function loadWasmTransmuxCoreHost(wasmUrl) {
-	if (wasmUrl === void 0) return createBundledWasmTransmuxCoreHost();
-	const wasmModule = normalizeWasmBindgenModule(await nativeDynamicImport(toWasmBindgenGlueUrl(wasmUrl)));
-	await wasmModule.default(wasmUrl);
-	return createWasmTransmuxCoreHost(wasmModule.TransmuxCore);
-}
-function toWasmBindgenGlueUrl(wasmUrl) {
-	const url = new URL(wasmUrl, globalThis.location?.href ?? "http://localhost/");
-	const path = url.pathname;
-	url.pathname = path.endsWith("_bg.wasm") ? `${path.slice(0, -8)}.js` : path.replace(/\.wasm$/u, ".js");
-	return url.href;
-}
-function normalizeWasmBindgenModule(value) {
-	if (!isRecord(value) || typeof value.default !== "function" || typeof value.TransmuxCore !== "function") throw new TypeError("WASM transmux module must export default init and TransmuxCore.");
-	return value;
-}
-function nativeDynamicImport(url) {
-	return new Function("url", "return import(url)")(url);
+	await __wbg_init(wasmUrl ?? new URL("./rivmux-transmux-core.wasm", import.meta.url));
+	return createWasmTransmuxCoreHost(TransmuxCore);
 }
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
+var Fmp4AppendBatcher = class {
+	pending = /* @__PURE__ */ new Map();
+	timers = /* @__PURE__ */ new Map();
+	maxDurationMs;
+	maxBytes;
+	onFlushDue;
+	constructor(onFlushDue, options = {}) {
+		this.onFlushDue = onFlushDue;
+		this.maxDurationMs = options.maxDurationMs ?? 125;
+		this.maxBytes = options.maxBytes ?? 524288;
+	}
+	push(segment) {
+		let batch = this.pending.get(segment.track);
+		if (batch !== void 0 && this.wouldExceedLimit(batch, segment)) {
+			const flushed = this.flush(segment.track);
+			batch = this.createBatch(segment);
+			this.pending.set(segment.track, batch);
+			this.scheduleFlush(segment.track);
+			return flushed;
+		}
+		if (batch === void 0) {
+			batch = this.createBatch(segment);
+			this.pending.set(segment.track, batch);
+			this.scheduleFlush(segment.track);
+		} else {
+			batch.dtsEndMs = Math.max(batch.dtsEndMs, segment.dtsEndMs);
+			batch.parts.push(segment.bytes);
+			batch.byteLength += segment.bytes.byteLength;
+		}
+		return batch.byteLength >= this.maxBytes ? this.flush(segment.track) : void 0;
+	}
+	flush(track) {
+		const batch = this.pending.get(track);
+		if (batch === void 0) return;
+		this.pending.delete(track);
+		this.cancelFlush(track);
+		return {
+			track,
+			dtsStartMs: batch.dtsStartMs,
+			dtsEndMs: batch.dtsEndMs,
+			keyframe: batch.keyframe,
+			bytes: mergeBytes(batch.parts, batch.byteLength)
+		};
+	}
+	flushAll() {
+		const batches = [];
+		for (const track of [...this.pending.keys()]) {
+			const batch = this.flush(track);
+			if (batch !== void 0) batches.push(batch);
+		}
+		return batches;
+	}
+	discard() {
+		this.pending.clear();
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+	}
+	createBatch(segment) {
+		return {
+			track: segment.track,
+			dtsStartMs: segment.dtsStartMs,
+			dtsEndMs: segment.dtsEndMs,
+			keyframe: segment.keyframe,
+			parts: [segment.bytes],
+			byteLength: segment.bytes.byteLength
+		};
+	}
+	wouldExceedLimit(batch, segment) {
+		return Math.max(batch.dtsEndMs, segment.dtsEndMs) - batch.dtsStartMs > this.maxDurationMs || batch.byteLength + segment.bytes.byteLength > this.maxBytes;
+	}
+	scheduleFlush(track) {
+		this.timers.set(track, setTimeout(() => {
+			this.timers.delete(track);
+			this.onFlushDue(track);
+		}, this.maxDurationMs));
+	}
+	cancelFlush(track) {
+		const timer = this.timers.get(track);
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			this.timers.delete(track);
+		}
+	}
+};
+function mergeBytes(parts, byteLength) {
+	const bytes = new Uint8Array(byteLength);
+	let offset = 0;
+	for (const part of parts) {
+		bytes.set(part, offset);
+		offset += part.byteLength;
+	}
+	return bytes;
 }
 //#endregion
-//#region src/runtime.ts
-var RuntimeWorker = class {
-	port;
+//#region src/runtime/append.ts
+/** Owns fMP4 batching and serialized MSE media-segment appends. */
+var RuntimeAppendController = class {
+	dependencies;
+	batcher;
+	generation = 0;
+	tail = Promise.resolve(true);
+	constructor(dependencies) {
+		this.dependencies = dependencies;
+	}
+	start(context) {
+		this.discard();
+		this.batcher = new Fmp4AppendBatcher((track) => {
+			const batch = this.batcher?.flush(track);
+			if (batch !== void 0) this.enqueue(batch, context);
+		});
+	}
+	push(segment, context) {
+		const batch = this.batcher?.push(segment);
+		return batch === void 0 ? void 0 : this.enqueue(batch, context);
+	}
+	async flush(context, track) {
+		const batcher = this.batcher;
+		if (batcher === void 0) return true;
+		const batches = track === void 0 ? batcher.flushAll() : [batcher.flush(track)].filter((batch) => batch !== void 0);
+		for (const batch of batches) if (!await this.enqueue(batch, context)) return false;
+		return true;
+	}
+	async waitForTail() {
+		return this.tail;
+	}
+	discard() {
+		this.generation += 1;
+		this.batcher?.discard();
+		this.batcher = void 0;
+		this.tail = Promise.resolve(true);
+	}
+	enqueue(segment, context) {
+		const generation = this.generation;
+		const append = this.tail.then(async (previousAppendSucceeded) => {
+			if (!previousAppendSucceeded || generation !== this.generation || !this.dependencies.isStarted() || !this.dependencies.isLifecycleContextCurrent(context)) return false;
+			if (!await this.dependencies.appendToMse(segment, context)) return false;
+			if (!this.dependencies.isLifecycleContextCurrent(context)) return false;
+			await this.dependencies.onAppended(segment, context);
+			return true;
+		});
+		this.tail = append.catch((cause) => {
+			if (this.dependencies.isLifecycleContextCurrent(context)) this.dependencies.onError(cause, context);
+			return false;
+		});
+		return this.tail;
+	}
+};
+//#endregion
+//#region src/runtime/session.ts
+/** Owns all resources that exist only for an attached playback session. */
+var RuntimeSession = class {
+	dependencies;
 	createMseController;
 	createLoader;
 	createTransmuxCore;
+	isStarted;
+	isLifecycleContextCurrent;
+	mse;
+	loader;
+	transmuxCore;
+	loaderRunId = 0;
+	loaderClosePromise;
+	outputBytes = 0;
+	appendController;
+	constructor(dependencies) {
+		this.dependencies = dependencies;
+		this.createMseController = dependencies.createMseController ?? (() => new MseController());
+		this.createLoader = dependencies.createLoader ?? ((config) => new HttpFlvLoader(config));
+		this.createTransmuxCore = dependencies.createTransmuxCore ?? ((options) => loadWasmTransmuxCoreHost(options.runtime.wasmUrl));
+		this.isStarted = dependencies.isStarted;
+		this.isLifecycleContextCurrent = dependencies.isLifecycleContextCurrent;
+		this.appendController = new RuntimeAppendController({
+			appendToMse: (segment, context) => this.appendToMse(context, () => this.mse?.appendMediaSegment(segment)),
+			isStarted: dependencies.isStarted,
+			isLifecycleContextCurrent: dependencies.isLifecycleContextCurrent,
+			onAppended: async (segment, context) => {
+				if (!this.isLifecycleContextCurrent(context)) return;
+				this.outputBytes += segment.bytes.byteLength;
+				await dependencies.onMediaAppended(context);
+			},
+			onError: dependencies.onAppendError
+		});
+	}
+	get hasMse() {
+		return this.mse !== void 0;
+	}
+	get loaderStats() {
+		return this.loader?.stats;
+	}
+	get loaderPaused() {
+		return this.loader?.paused ?? false;
+	}
+	get bufferedRanges() {
+		return this.mse?.bufferedRanges ?? [];
+	}
+	get emittedBytes() {
+		return this.outputBytes;
+	}
+	async attach(context) {
+		this.mse ??= this.createMseController();
+		const attachment = await raceLifecycleOperation(this.mse.createMediaSourceHandle(), context.signal);
+		if (attachment.cancelled || !this.isLifecycleContextCurrent(context)) return;
+		return attachment.value;
+	}
+	async createCore(options, context) {
+		const creation = await raceLifecycleOperation(Promise.resolve(this.createTransmuxCore(options)), context.signal, (lateCore) => lateCore?.destroy());
+		if (creation.cancelled || !this.isLifecycleContextCurrent(context)) return;
+		return creation.value;
+	}
+	start(core, context) {
+		this.transmuxCore?.destroy();
+		this.transmuxCore = core;
+		this.outputBytes = 0;
+		this.appendController.start(context);
+	}
+	runLoader(config, context) {
+		const { loader, runId } = this.startLoader(config);
+		this.consumeLoader(loader, runId, context);
+	}
+	async close() {
+		this.dependencies.onLoaderClosing();
+		this.appendController.discard();
+		this.transmuxCore?.destroy();
+		this.transmuxCore = void 0;
+		const loader = this.loader;
+		if (loader === void 0) {
+			await this.loaderClosePromise;
+			return;
+		}
+		this.loader = void 0;
+		this.loaderRunId += 1;
+		await this.closeLoaderInstance(loader);
+	}
+	destroyMse() {
+		this.mse?.destroy();
+		this.mse = void 0;
+	}
+	discardAppend() {
+		this.appendController.discard();
+	}
+	collectMseStats() {
+		return {
+			appendQueueLength: this.mse?.appendQueueLength ?? 0,
+			appendQueueBytes: this.mse?.appendQueueBytes ?? 0,
+			sourceBufferUpdating: this.mse?.sourceBufferUpdating ?? false,
+			sourceBufferCount: this.mse?.sourceBufferCount ?? 0,
+			bufferedRangeCount: this.mse?.bufferedRangeCount ?? 0,
+			bufferedStart: this.mse?.bufferedStart,
+			bufferedEnd: this.mse?.bufferedEnd,
+			bufferedDuration: this.mse?.bufferedDuration
+		};
+	}
+	cleanupBefore(cutoff, force = false) {
+		return this.mse?.cleanupBefore(cutoff, force ? { force: true } : void 0);
+	}
+	pauseLoader() {
+		this.loader?.pause();
+	}
+	resumeLoader() {
+		this.loader?.resume();
+	}
+	startLoader(config) {
+		const loader = this.createLoader(config);
+		const runId = this.loaderRunId + 1;
+		this.loaderRunId = runId;
+		this.loader = loader;
+		return {
+			loader,
+			runId
+		};
+	}
+	pushChunk(bytes) {
+		return this.transmuxCore?.pushChunk(bytes) ?? [];
+	}
+	isCurrentLoader(loader, runId) {
+		return this.loader === loader && this.loaderRunId === runId && this.isStarted();
+	}
+	async closeCurrentLoader(loader, runId) {
+		if (this.loader !== loader || this.loaderRunId !== runId) return;
+		this.dependencies.onLoaderClosing();
+		this.appendController.discard();
+		this.loader = void 0;
+		this.loaderRunId += 1;
+		this.transmuxCore?.destroy();
+		this.transmuxCore = void 0;
+		await this.closeLoaderInstance(loader);
+	}
+	async closeLoaderInstance(loader) {
+		let closing;
+		try {
+			closing = loader.close();
+		} catch (cause) {
+			closing = Promise.reject(cause);
+		}
+		this.loaderClosePromise = closing;
+		try {
+			await closing;
+		} finally {
+			if (this.loaderClosePromise === closing) this.loaderClosePromise = void 0;
+		}
+	}
+	async consumeLoader(loader, runId, context) {
+		try {
+			await loader.open();
+			while (this.isCurrentLoader(loader, runId) && this.isLifecycleContextCurrent(context)) {
+				await this.dependencies.applyLatencyPolicy(context);
+				if (!this.isCurrentLoader(loader, runId) || !this.isLifecycleContextCurrent(context)) return;
+				const chunk = await loader.read();
+				if (chunk === null || !this.isCurrentLoader(loader, runId) || !this.isLifecycleContextCurrent(context)) break;
+				this.dependencies.onStats(loader.stats);
+				if (!await this.processEvents(this.pushChunk(chunk.bytes), context)) {
+					await this.closeCurrentLoader(loader, runId);
+					return;
+				}
+				await this.dependencies.applyLatencyPolicy(context);
+				if (!this.isCurrentLoader(loader, runId) || !this.isLifecycleContextCurrent(context)) return;
+				this.dependencies.onStats(loader.stats);
+			}
+			if (this.isCurrentLoader(loader, runId) && this.isLifecycleContextCurrent(context)) {
+				if (!await this.appendController.flush(context)) return;
+				this.dependencies.onStats(loader.stats);
+			}
+		} catch (cause) {
+			if (!this.isCurrentLoader(loader, runId) || isAbortLikeError(cause)) return;
+			try {
+				await this.closeCurrentLoader(loader, runId);
+			} catch {}
+			if (!this.isLifecycleContextCurrent(context)) return;
+			const code = cause instanceof HttpFlvLoaderError ? cause.code : "RIVMUX_HTTP_LOADER_FAILED";
+			this.dependencies.onFailure("network", code, "HTTP Fetch loader failed.", cause);
+		} finally {
+			if (this.isCurrentLoader(loader, runId)) try {
+				await this.closeCurrentLoader(loader, runId);
+			} catch (cause) {
+				if (this.isLifecycleContextCurrent(context)) this.dependencies.onFailure("network", "RIVMUX_HTTP_LOADER_CLOSE_FAILED", "HTTP Fetch loader failed to close.", cause);
+			}
+		}
+	}
+	async processEvents(events, context) {
+		for (const event of events) {
+			if (!this.isLifecycleContextCurrent(context)) return false;
+			switch (event.type) {
+				case "mediaInfo":
+					this.dependencies.onMessage({
+						type: "media-info",
+						mediaInfo: coreMediaInfoToPlayerMediaInfo(event.data)
+					});
+					break;
+				case "warning":
+					this.dependencies.onMessage({
+						type: "warning",
+						warning: coreWarningToPlayerWarning(event.data)
+					});
+					break;
+				case "fatalError":
+					this.dependencies.onPlayerError(coreErrorToPlayerError(event.data));
+					return false;
+				case "initSegment":
+					if (!await this.appendController.flush(context)) return false;
+					if (!await this.appendToMse(context, () => this.mse?.appendInitSegment(event.data))) return false;
+					if (!this.isLifecycleContextCurrent(context)) return false;
+					this.outputBytes += event.data.bytes.byteLength;
+					await this.dependencies.applyLatencyPolicy(context);
+					break;
+				case "mediaSegment": {
+					const append = this.appendController.push(event.data, context);
+					if (append !== void 0 && !await append) return false;
+					break;
+				}
+				case "probeResult":
+				case "trackConfig":
+				case "sample":
+				case "metadata":
+				case "discontinuity": break;
+			}
+		}
+		return this.appendController.waitForTail();
+	}
+	async appendToMse(context, append) {
+		try {
+			if ((await raceLifecycleOperation(Promise.resolve(append()), context.signal)).cancelled || !this.isLifecycleContextCurrent(context)) return false;
+			return true;
+		} catch (cause) {
+			if (!this.isLifecycleContextCurrent(context)) return false;
+			if (isQuotaExceededError(cause) && await this.retryAppendAfterQuotaCleanup(context, append)) return true;
+			if (cause instanceof MseUnsupportedMimeError) {
+				this.dependencies.onFailure("unsupported", "RIVMUX_UNSUPPORTED_MSE_CODEC", cause.message, cause);
+				return false;
+			}
+			this.dependencies.onFailure("mse", "RIVMUX_MSE_APPEND_FAILED", "MSE append failed.", cause);
+			return false;
+		}
+	}
+	async retryAppendAfterQuotaCleanup(context, append) {
+		const cutoff = this.dependencies.quotaCleanupCutoff();
+		if (cutoff === void 0 || cutoff <= 0) return false;
+		try {
+			if ((await raceLifecycleOperation(Promise.resolve(this.cleanupBefore(cutoff, true)), context.signal)).cancelled || !this.isLifecycleContextCurrent(context)) return false;
+			if ((await raceLifecycleOperation(Promise.resolve(append()), context.signal)).cancelled || !this.isLifecycleContextCurrent(context)) return false;
+			this.dependencies.onMessage({
+				type: "warning",
+				warning: {
+					code: "RIVMUX_MSE_QUOTA_RETRY",
+					message: "MSE quota was exceeded; old buffered ranges were cleaned before retrying append."
+				}
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+function isQuotaExceededError(cause) {
+	return typeof cause === "object" && cause !== null && "name" in cause && cause.name === "QuotaExceededError";
+}
+//#endregion
+//#region src/runtime/index.ts
+var RuntimeWorker = class {
+	port;
 	detectRuntime;
 	now;
 	state = "idle";
 	url;
 	options;
-	mse;
-	loader;
-	transmuxCore;
+	session;
 	latencyController;
 	videoState;
 	lastLatencyMetrics = {};
 	statsTimer;
 	statsTickInFlight = false;
-	loaderRunId = 0;
-	outputBytes = 0;
 	appendQueueMaxLength = 0;
 	appendQueueMaxBytes = 0;
+	commandTail = Promise.resolve();
+	lifecycleGeneration = 0;
+	lifecycleAbortController = new AbortController();
+	fatalCleanupPromise = Promise.resolve();
 	constructor(port, dependencies = {}) {
 		this.port = port;
-		this.createMseController = dependencies.createMseController ?? (() => new MseController());
-		this.createLoader = dependencies.createLoader ?? ((config) => new HttpFlvLoader(config));
-		this.createTransmuxCore = dependencies.createTransmuxCore ?? ((options) => loadWasmTransmuxCoreHost(options.runtime.wasmUrl));
 		this.detectRuntime = dependencies.detectRuntime ?? detectWorkerRuntime;
 		this.now = dependencies.now ?? (() => performance.now());
+		this.session = new RuntimeSession({
+			...dependencies,
+			isStarted: () => this.state === "started",
+			isLifecycleContextCurrent: (context) => this.isLifecycleContextCurrent(context),
+			onMediaAppended: (context) => this.applyLatencyPolicy(context),
+			onAppendError: (cause, context) => {
+				if (this.isLifecycleContextCurrent(context)) this.fail("mse", "RIVMUX_MSE_APPEND_FAILED", "MSE append failed.", true, cause);
+			},
+			onLoaderClosing: () => this.stopStatsTimer(),
+			onStats: (stats) => this.postStats(stats),
+			onMessage: (message) => this.post(message),
+			onFailure: (kind, code, message, cause) => this.fail(kind, code, message, true, cause),
+			onPlayerError: (error) => this.failWithError(error),
+			applyLatencyPolicy: (context) => this.applyLatencyPolicy(context),
+			quotaCleanupCutoff: () => this.quotaCleanupCutoff()
+		});
+	}
+	handleCommand(command) {
+		if (command.type === "stop" || command.type === "destroy") this.invalidateLifecycle();
+		const context = {
+			generation: this.lifecycleGeneration,
+			signal: this.lifecycleAbortController.signal
+		};
+		const handling = this.commandTail.then(() => this.executeCommand(command, context));
+		this.commandTail = handling.catch(() => void 0);
+		return handling;
 	}
-	async handleCommand(command) {
+	async executeCommand(command, context) {
 		if (this.state === "destroyed") return;
-		if (this.state === "fatal-error" && command.type !== "destroy") return;
+		if ((command.type === "attach-media-source" || command.type === "start") && !this.isLifecycleContextCurrent(context)) return;
+		if (this.state === "fatal-error") {
+			if (command.type === "stop") this.post({ type: "stopped" });
+			if (command.type !== "destroy") return;
+		}
 		try {
 			switch (command.type) {
 				case "init":
@@ -1187,10 +1653,10 @@ var RuntimeWorker = class {
 					this.post({ type: "ready" });
 					return;
 				case "attach-media-source":
-					await this.attachMediaSource();
+					await this.attachMediaSource(context);
 					return;
 				case "start":
-					await this.start();
+					await this.start(context);
 					return;
 				case "stop":
 					await this.stop();
@@ -1201,8 +1667,7 @@ var RuntimeWorker = class {
 					return;
 				case "video-state":
 					this.videoState = command.state;
-					await this.applyLatencyPolicy();
-					this.postStats();
+					if (!(await raceLifecycleOperation(this.applyLatencyPolicy(context), context.signal)).cancelled && this.isLifecycleContextCurrent(context) && this.state === "started") this.postStats();
 					return;
 				case "playback-control-result":
 					this.latencyController?.recordPlaybackControlResult(command.result);
@@ -1215,57 +1680,55 @@ var RuntimeWorker = class {
 			this.fail("runtime", "RIVMUX_WORKER_COMMAND_FAILED", "Worker command failed.", true, cause);
 		}
 	}
-	async attachMediaSource() {
+	async attachMediaSource(context) {
 		if (this.state === "idle") {
 			this.fail("runtime", "RIVMUX_WORKER_NOT_INITIALIZED", "Worker must be initialized before attach.", true);
 			return;
 		}
-		if (this.mse === void 0) this.mse = this.createMseController();
 		try {
-			const handle = await this.mse.createMediaSourceHandle();
+			const handle = await this.session.attach(context);
+			if (handle === void 0 || context.generation !== this.lifecycleGeneration) return;
 			this.post({
 				type: "media-source-handle",
 				handle
 			}, [handle]);
 			this.state = "attached";
 		} catch (cause) {
+			if (context.generation !== this.lifecycleGeneration) return;
 			this.fail("mse", "RIVMUX_MSE_ATTACH_FAILED", "MSE media source attachment failed.", true, cause);
 		}
 	}
-	async start() {
+	async start(context) {
 		const options = this.options;
-		if (this.mse === void 0 || options === void 0 || this.state === "idle" || this.state === "ready") {
+		if (!this.session.hasMse || options === void 0 || this.state === "idle" || this.state === "ready") {
 			this.fail("runtime", "RIVMUX_WORKER_START_REQUIRES_ATTACH", "Worker start requires an attached MediaSource.", true);
 			return;
 		}
 		if (this.state === "started") return;
-		let transmuxCore;
 		try {
-			const createdCore = await this.createTransmuxCore(options);
-			if (createdCore === void 0) {
+			const transmuxCore = await this.session.createCore(options, context);
+			if (context.generation !== this.lifecycleGeneration) return;
+			if (transmuxCore === void 0) {
 				this.fail("runtime", "RIVMUX_TRANSMUX_CORE_UNAVAILABLE", "Transmux core is not available.", true);
 				return;
 			}
-			transmuxCore = createdCore;
+			this.session.start(transmuxCore, context);
 		} catch (cause) {
+			if (context.generation !== this.lifecycleGeneration) return;
 			this.fail("runtime", "RIVMUX_TRANSMUX_CORE_UNAVAILABLE", "Transmux core is not available.", true, cause);
 			return;
 		}
-		this.transmuxCore?.destroy();
-		this.transmuxCore = transmuxCore;
 		this.state = "started";
-		this.outputBytes = 0;
 		this.appendQueueMaxLength = 0;
 		this.appendQueueMaxBytes = 0;
+		if ((await raceLifecycleOperation(this.applyLatencyPolicy(context), context.signal)).cancelled || !this.isLifecycleContextCurrent(context)) return;
 		this.startStatsTimer();
-		await this.applyLatencyPolicy();
 		this.postStats();
-		this.startLoader();
+		this.startLoader(context);
 	}
 	async stop() {
 		await this.closeLoader();
-		this.mse?.destroy();
-		this.mse = void 0;
+		this.session.destroyMse();
 		this.latencyController?.reset();
 		this.videoState = void 0;
 		this.lastLatencyMetrics = {};
@@ -1273,9 +1736,9 @@ var RuntimeWorker = class {
 		this.post({ type: "stopped" });
 	}
 	async destroy() {
+		await this.fatalCleanupPromise;
 		await this.closeLoader();
-		this.mse?.destroy();
-		this.mse = void 0;
+		this.session.destroyMse();
 		this.latencyController?.reset();
 		this.videoState = void 0;
 		this.lastLatencyMetrics = {};
@@ -1283,199 +1746,70 @@ var RuntimeWorker = class {
 		this.post({ type: "destroyed" });
 		this.port.close();
 	}
-	startLoader() {
+	startLoader(context) {
 		const options = this.options;
 		const url = this.url;
 		if (options === void 0 || url === void 0) {
 			this.fail("runtime", "RIVMUX_WORKER_NOT_INITIALIZED", "Worker must be initialized before loader start.", true);
 			return;
 		}
-		const loader = this.createLoader({
+		this.session.runLoader({
 			url,
 			network: options.network
-		});
-		const runId = this.loaderRunId + 1;
-		this.loaderRunId = runId;
-		this.loader = loader;
-		this.runLoader(loader, runId);
-	}
-	async runLoader(loader, runId) {
-		try {
-			await loader.open();
-			while (this.isCurrentLoader(loader, runId)) {
-				await this.applyLatencyPolicy();
-				const chunk = await loader.read();
-				if (chunk === null) break;
-				this.postStats(loader.stats);
-				if (!await this.processTransmuxEvents(this.transmuxCore?.pushChunk(chunk.bytes) ?? [])) {
-					await this.closeCurrentLoader(loader, runId);
-					return;
-				}
-				await this.applyLatencyPolicy();
-				this.postStats(loader.stats);
-			}
-		} catch (cause) {
-			if (!this.isCurrentLoader(loader, runId) || isAbortLikeError(cause)) return;
-			await this.closeCurrentLoader(loader, runId);
-			this.fail("network", getNetworkErrorCode(cause), "HTTP Fetch loader failed.", true, cause);
-			return;
-		} finally {
-			if (this.isCurrentLoader(loader, runId)) await this.closeCurrentLoader(loader, runId);
-		}
+		}, context);
 	}
 	async closeLoader() {
 		this.stopStatsTimer();
-		const loader = this.loader;
-		if (loader === void 0) return;
-		this.loader = void 0;
-		this.loaderRunId += 1;
-		this.transmuxCore?.destroy();
-		this.transmuxCore = void 0;
-		await loader.close();
-	}
-	async closeCurrentLoader(loader, runId) {
-		if (this.loader !== loader || this.loaderRunId !== runId) return;
-		this.stopStatsTimer();
-		this.loader = void 0;
-		this.loaderRunId += 1;
-		this.transmuxCore?.destroy();
-		this.transmuxCore = void 0;
-		await loader.close();
-	}
-	isCurrentLoader(loader, runId) {
-		return this.loader === loader && this.loaderRunId === runId && this.state === "started";
+		await this.session.close();
 	}
 	postStats(loaderStats) {
-		const metrics = this.lastLatencyMetrics;
 		const mseStats = this.collectMseStats();
-		const loaderSnapshot = loaderStats ?? this.loader?.stats;
+		const loaderSnapshot = loaderStats ?? this.session.loaderStats;
 		this.post({
 			type: "stats",
-			stats: {
-				bytesReceived: loaderSnapshot?.bytesReceived ?? 0,
-				currentNetworkSpeed: loaderSnapshot?.currentNetworkSpeed ?? 0,
-				networkIdleMs: getNetworkIdleMs(loaderSnapshot, this.now()),
-				outputBytes: this.outputBytes,
-				appendQueueLength: mseStats.appendQueueLength,
-				appendQueueBytes: mseStats.appendQueueBytes,
+			stats: createPlayerStats({
+				loaderStats: loaderSnapshot,
+				mseStats,
+				latencyMetrics: this.lastLatencyMetrics,
+				outputBytes: this.session.emittedBytes,
 				appendQueueMaxLength: this.appendQueueMaxLength,
 				appendQueueMaxBytes: this.appendQueueMaxBytes,
-				loaderPaused: this.loader?.paused ?? false,
-				sourceBufferUpdating: mseStats.sourceBufferUpdating,
-				sourceBufferCount: mseStats.sourceBufferCount,
-				bufferedStart: metrics.bufferedStart ?? this.mse?.bufferedStart,
-				bufferedEnd: metrics.bufferedEnd ?? this.mse?.bufferedEnd,
-				bufferedDuration: metrics.bufferedDuration ?? this.mse?.bufferedDuration,
-				bufferedRangeCount: mseStats.bufferedRangeCount,
-				currentTime: metrics.currentTime,
-				liveLatency: metrics.liveLatency,
-				playbackRate: metrics.playbackRate,
-				readyState: metrics.readyState,
-				droppedFrames: metrics.droppedFrames
-			}
+				loaderPaused: this.session.loaderPaused,
+				nowMs: this.now()
+			})
 		});
 	}
-	async processTransmuxEvents(events) {
-		for (const event of events) switch (event.type) {
-			case "mediaInfo":
-				this.post({
-					type: "media-info",
-					mediaInfo: coreMediaInfoToPlayerMediaInfo(event.data)
-				});
-				break;
-			case "warning":
-				this.post({
-					type: "warning",
-					warning: coreWarningToPlayerWarning(event.data)
-				});
-				break;
-			case "fatalError":
-				this.failWithError(coreErrorToPlayerError(event.data));
-				return false;
-			case "initSegment":
-				if (!await this.appendToMse(() => this.mse?.appendInitSegment(event.data))) return false;
-				this.outputBytes += event.data.bytes.byteLength;
-				await this.applyLatencyPolicy();
-				break;
-			case "mediaSegment":
-				if (!await this.appendToMse(() => this.mse?.appendMediaSegment(event.data))) return false;
-				this.outputBytes += event.data.bytes.byteLength;
-				await this.applyLatencyPolicy();
-				break;
-			case "probeResult":
-			case "videoConfig":
-			case "audioConfig":
-			case "videoSample":
-			case "audioSample":
-			case "metadata":
-			case "discontinuity": break;
-		}
-		return true;
-	}
 	collectMseStats() {
-		const appendQueueLength = this.mse?.appendQueueLength ?? 0;
-		const appendQueueBytes = this.mse?.appendQueueBytes ?? 0;
-		this.appendQueueMaxLength = Math.max(this.appendQueueMaxLength, appendQueueLength);
-		this.appendQueueMaxBytes = Math.max(this.appendQueueMaxBytes, appendQueueBytes);
-		return {
-			appendQueueLength,
-			appendQueueBytes,
-			sourceBufferUpdating: this.mse?.sourceBufferUpdating ?? false,
-			sourceBufferCount: this.mse?.sourceBufferCount ?? 0,
-			bufferedRangeCount: this.mse?.bufferedRangeCount ?? 0
-		};
-	}
-	async appendToMse(append) {
-		try {
-			await append();
-			return true;
-		} catch (cause) {
-			if (isQuotaExceededError(cause) && await this.retryAppendAfterQuotaCleanup(append)) return true;
-			this.fail("mse", "RIVMUX_MSE_APPEND_FAILED", "MSE append failed.", true, cause);
-			return false;
-		}
-	}
-	async retryAppendAfterQuotaCleanup(append) {
-		const mse = this.mse;
-		const cutoff = this.quotaCleanupCutoff();
-		if (mse === void 0 || cutoff === void 0 || cutoff <= 0) return false;
-		try {
-			await mse.cleanupBefore(cutoff, { force: true });
-			await append();
-			this.post({
-				type: "warning",
-				warning: {
-					code: "RIVMUX_MSE_QUOTA_RETRY",
-					message: "MSE quota was exceeded; old buffered ranges were cleaned before retrying append."
-				}
-			});
-			return true;
-		} catch {
-			return false;
-		}
+		const stats = this.session.collectMseStats();
+		const highWaterMark = updateAppendQueueHighWaterMark({
+			length: this.appendQueueMaxLength,
+			bytes: this.appendQueueMaxBytes
+		}, stats);
+		this.appendQueueMaxLength = highWaterMark.length;
+		this.appendQueueMaxBytes = highWaterMark.bytes;
+		return { ...stats };
 	}
 	quotaCleanupCutoff() {
 		const backwardBuffer = this.options?.latency.backwardBuffer ?? 0;
 		const currentTime = this.videoState?.currentTime;
 		if (currentTime !== void 0 && Number.isFinite(currentTime)) return Math.max(0, currentTime - backwardBuffer);
-		const bufferedEnd = this.mse?.bufferedEnd;
+		const bufferedEnd = this.session.collectMseStats().bufferedEnd;
 		return bufferedEnd === void 0 ? void 0 : Math.max(0, bufferedEnd - backwardBuffer);
 	}
-	async applyLatencyPolicy() {
+	async applyLatencyPolicy(context) {
 		const latencyController = this.latencyController;
-		const mse = this.mse;
-		if (latencyController === void 0 || mse === void 0) return;
-		const loader = this.loader;
+		if (latencyController === void 0 || !this.session.hasMse) return;
 		const evaluation = latencyController.evaluate({
-			ranges: mse.bufferedRanges,
+			ranges: this.session.bufferedRanges,
 			videoState: this.videoState,
-			loaderPaused: loader?.paused ?? false,
+			loaderPaused: this.session.loaderPaused,
 			nowMs: this.now()
 		});
 		this.lastLatencyMetrics = evaluation.metrics;
-		if (evaluation.cleanupBefore !== void 0) await mse.cleanupBefore(evaluation.cleanupBefore);
-		if (loader !== void 0 && evaluation.loaderCommand === "pause") loader.pause();
-		else if (loader !== void 0 && evaluation.loaderCommand === "resume") loader.resume();
+		if (evaluation.cleanupBefore !== void 0) await this.session.cleanupBefore(evaluation.cleanupBefore);
+		if (context !== void 0 && !this.isLifecycleContextCurrent(context)) return;
+		if (evaluation.loaderCommand === "pause") this.session.pauseLoader();
+		else if (evaluation.loaderCommand === "resume") this.session.resumeLoader();
 		if (evaluation.playbackControl !== void 0) this.post({
 			type: "playback-control",
 			action: evaluation.playbackControl
@@ -1498,15 +1832,25 @@ var RuntimeWorker = class {
 	async emitStatsTick() {
 		if (this.statsTickInFlight || this.state !== "started") return;
 		this.statsTickInFlight = true;
+		const context = this.currentLifecycleContext();
 		try {
-			await this.applyLatencyPolicy();
-			this.postStats();
+			if (!(await raceLifecycleOperation(this.applyLatencyPolicy(context), context.signal)).cancelled && this.isLifecycleContextCurrent(context) && this.state === "started") this.postStats();
 		} catch (cause) {
+			if (!this.isLifecycleContextCurrent(context)) return;
 			this.fail("mse", "RIVMUX_MSE_LATENCY_POLICY_FAILED", "MSE latency policy failed.", true, cause);
 		} finally {
 			this.statsTickInFlight = false;
 		}
 	}
+	currentLifecycleContext() {
+		return {
+			generation: this.lifecycleGeneration,
+			signal: this.lifecycleAbortController.signal
+		};
+	}
+	isLifecycleContextCurrent(context) {
+		return !context.signal.aborted && context.generation === this.lifecycleGeneration;
+	}
 	fail(kind, code, message, terminal, cause) {
 		const error = cause === void 0 ? {
 			kind,
@@ -1523,6 +1867,7 @@ var RuntimeWorker = class {
 		this.failWithError(error);
 	}
 	failWithError(error) {
+		if (this.state === "destroyed") return;
 		if (error.terminal) this.enterFatalErrorState();
 		this.post({
 			type: "error",
@@ -1530,11 +1875,12 @@ var RuntimeWorker = class {
 		});
 	}
 	enterFatalErrorState() {
-		if (this.state === "fatal-error") return;
+		if (this.state === "fatal-error" || this.state === "destroyed") return;
 		this.state = "fatal-error";
-		this.closeLoader();
-		this.mse?.destroy();
-		this.mse = void 0;
+		this.invalidateLifecycle();
+		this.session.discardAppend();
+		this.fatalCleanupPromise = this.closeLoader().catch(() => void 0);
+		this.session.destroyMse();
 		this.latencyController?.reset();
 		this.videoState = void 0;
 		this.lastLatencyMetrics = {};
@@ -1542,15 +1888,12 @@ var RuntimeWorker = class {
 	post(message, transfer) {
 		this.port.postMessage(message, transfer);
 	}
+	invalidateLifecycle() {
+		this.lifecycleGeneration += 1;
+		this.lifecycleAbortController.abort();
+		this.lifecycleAbortController = new AbortController();
+	}
 };
-function getNetworkErrorCode(cause) {
-	return cause instanceof HttpFlvLoaderError ? cause.code : "RIVMUX_HTTP_LOADER_FAILED";
-}
-function getNetworkIdleMs(stats, nowMs) {
-	const markerMs = stats?.lastChunkAtMs ?? stats?.startedAtMs;
-	if (markerMs === void 0) return;
-	return Math.max(nowMs - markerMs, 0);
-}
 function serializeCause(cause) {
 	if (cause instanceof Error) return {
 		name: cause.name,
@@ -1558,12 +1901,6 @@ function serializeCause(cause) {
 	};
 	return cause;
 }
-function isQuotaExceededError(cause) {
-	return isNamedError(cause, "QuotaExceededError");
-}
-function isNamedError(value, name) {
-	return typeof value === "object" && value !== null && "name" in value && value.name === name;
-}
 function detectWorkerRuntime() {
 	if (typeof fetch !== "function") return createUnsupportedRuntimeError("RIVMUX_UNSUPPORTED_FETCH", "Fetch is not available in this worker runtime.");
 	if (typeof ReadableStream === "undefined") return createUnsupportedRuntimeError("RIVMUX_UNSUPPORTED_READABLE_STREAM", "ReadableStream is not available in this worker runtime.");
@@ -1571,7 +1908,6 @@ function detectWorkerRuntime() {
 	if (typeof MediaSource === "undefined") return createUnsupportedRuntimeError("RIVMUX_UNSUPPORTED_MSE", "MediaSource is not available in this worker runtime.");
 	if (MediaSource.canConstructInDedicatedWorker !== true) return createUnsupportedRuntimeError("RIVMUX_UNSUPPORTED_WORKER_MSE", "MediaSource cannot be constructed in this worker runtime.");
 	if (typeof MediaSource.isTypeSupported !== "function") return createUnsupportedRuntimeError("RIVMUX_UNSUPPORTED_MSE_TYPE_CHECK", "MediaSource.isTypeSupported is not available in this worker runtime.");
-	for (const requirement of REQUIRED_MSE_MIME_TYPES) if (!MediaSource.isTypeSupported(requirement.mimeType)) return createUnsupportedRuntimeError(requirement.unsupportedCode, `MSE does not support ${requirement.mimeType}.`);
 }
 function createUnsupportedRuntimeError(code, message) {
 	return {
@@ -1587,38 +1923,6 @@ function createLatencyController(options) {
 		playback: options.playback
 	});
 }
-function mergeOptions(current, updates) {
-	return {
-		playback: {
-			...current.playback,
-			...updates.playback
-		},
-		latency: {
-			...current.latency,
-			...updates.latency
-		},
-		network: {
-			...current.network,
-			...updates.network,
-			headers: {
-				...current.network.headers,
-				...updates.network?.headers
-			},
-			retry: {
-				...current.network.retry,
-				...updates.network?.retry
-			}
-		},
-		runtime: {
-			...current.runtime,
-			...updates.runtime
-		},
-		diagnostics: {
-			...current.diagnostics,
-			...updates.diagnostics
-		}
-	};
-}
 //#endregion
 //#region src/worker-entry.ts
 function startRuntimeWorker(scope) {