@rivmux/runtime-worker 0.4.0 → 0.5.0

package/dist/rivmux-runtime-worker.js

@@ -141,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 {
@@ -349,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
@@ -518,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;
@@ -533,7 +638,7 @@ var MseController = class {
 		await this.ensureQueue(segment.track, mimeType).append(toAppendBuffer(segment.bytes));
 	}
 	async appendMediaSegment(segment) {
-		const queue = this.queues.get(segment.track);
+		const queue = this.queues.get(segment.track) ?? this.queues.get("muxed");
 		if (queue === void 0) throw new Error(`Cannot append ${segment.track} media segment before init segment.`);
 		await queue.append(toAppendBuffer(segment.bytes));
 		const mediaSource = this.requireMediaSource();
@@ -677,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,
@@ -840,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();
@@ -862,18 +958,11 @@ 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);
@@ -886,10 +975,13 @@ function __wbg_get_imports() {
 		"./rivmux_transmux_core_bg.js": {
 			__proto__: null,
 			__wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
-				return addHeapObject(Error(getStringFromWasm0(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(getObject(arg1)), wasm.__wbindgen_export, wasm.__wbindgen_export2);
+				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);
@@ -898,31 +990,34 @@ function __wbg_get_imports() {
 				throw new Error(getStringFromWasm0(arg0, arg1));
 			},
 			__wbg_new_2e117a478906f062: function() {
-				return addHeapObject(/* @__PURE__ */ new Object());
+				return /* @__PURE__ */ new Object();
 			},
 			__wbg_new_36e147a8ced3c6e0: function() {
-				return addHeapObject(new Array());
+				return new Array();
 			},
 			__wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
-				getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+				arg0[arg1] = arg2;
 			},
 			__wbg_set_dc601f4a69da0bc2: function(arg0, arg1, arg2) {
-				getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+				arg0[arg1 >>> 0] = arg2;
 			},
 			__wbindgen_cast_0000000000000001: function(arg0) {
-				return addHeapObject(arg0);
+				return arg0;
 			},
 			__wbindgen_cast_0000000000000002: function(arg0) {
-				return addHeapObject(arg0);
+				return arg0;
 			},
 			__wbindgen_cast_0000000000000003: function(arg0, arg1) {
-				return addHeapObject(getStringFromWasm0(arg0, arg1));
+				return getStringFromWasm0(arg0, arg1);
 			},
-			__wbindgen_object_clone_ref: function(arg0) {
-				return addHeapObject(getObject(arg0));
-			},
-			__wbindgen_object_drop_ref: function(arg0) {
-				takeObject(arg0);
+			__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);
 			}
 		}
 	};
@@ -931,18 +1026,6 @@ 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);
@@ -956,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);
@@ -996,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,
@@ -1035,6 +1112,7 @@ function __wbg_finalize_init(instance, module) {
 	wasm = instance.exports;
 	cachedDataViewMemory0 = null;
 	cachedUint8ArrayMemory0 = null;
+	wasm.__wbindgen_start();
 	return wasm;
 }
 async function __wbg_load(module, imports) {
@@ -1084,41 +1162,480 @@ async function loadWasmTransmuxCoreHost(wasmUrl) {
 	await __wbg_init(wasmUrl ?? new URL("./rivmux-transmux-core.wasm", import.meta.url));
 	return createWasmTransmuxCoreHost(TransmuxCore);
 }
+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":
@@ -1136,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();
@@ -1150,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);
@@ -1164,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 = {};
@@ -1222,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 = {};
@@ -1232,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
@@ -1447,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,
@@ -1472,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",
@@ -1479,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 = {};
@@ -1491,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,
@@ -1507,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.");
@@ -1520,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 {
@@ -1536,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) {