@rivmux/runtime-worker 0.4.0 → 1.0.0-rc.1

package/dist/rivmux-runtime-worker.js

@@ -141,46 +141,44 @@ const PLAYBACK_RATE_RESTORE_THRESHOLD_SECONDS = .1;
 const SEEK_COOLDOWN_MS = 1e3;
 const SEEK_MIN_DELTA_SECONDS = .1;
 //#endregion
-//#region src/loader/retry-policy.ts
-function createRetryPolicy(input) {
-	return {
-		maxAttempts: clampInteger(input?.maxAttempts, 1),
-		backoffMs: clampInteger(input?.backoffMs, 0)
-	};
-}
-function getRetryDelayMs(policy, attempt) {
-	if (policy.backoffMs === 0) return 0;
-	return policy.backoffMs * Math.max(1, attempt);
-}
-function clampInteger(value, minimum) {
-	if (value === void 0 || !Number.isFinite(value)) return minimum;
-	return Math.max(minimum, Math.trunc(value));
-}
-//#endregion
 //#region src/loader/http-flv-loader.ts
+/** Structured failure raised by one HTTP-FLV connection. */
 var HttpFlvLoaderError = class extends Error {
 	code;
+	phase;
+	reason;
 	status;
-	constructor(code, message, status) {
-		super(message);
+	cause;
+	constructor(code, message, options) {
+		const normalizedOptions = typeof options === "number" ? {
+			phase: "open",
+			reason: "http-status",
+			status: options
+		} : options ?? { phase: "open" };
+		super(message, normalizedOptions.cause === void 0 ? void 0 : { cause: normalizedOptions.cause });
 		this.name = "HttpFlvLoaderError";
 		this.code = code;
-		this.status = status;
+		this.phase = normalizedOptions.phase;
+		this.reason = normalizedOptions.reason;
+		this.status = normalizedOptions.status;
+		this.cause = normalizedOptions.cause;
 	}
 };
 var HttpFlvLoader = class {
 	url;
 	headers;
 	credentials;
-	retry = createRetryPolicy(void 0);
+	readIdleTimeoutMs;
 	fetchImpl;
 	now;
-	sleep;
+	setTimer;
+	clearTimer;
 	abortController;
 	reader;
 	state = "idle";
 	pausedState = false;
 	resumeWaiters = [];
+	activeReadTimeout;
 	mutableStats = {
 		bytesReceived: 0,
 		currentNetworkSpeed: 0
@@ -189,10 +187,11 @@ var HttpFlvLoader = class {
 		this.url = config.url;
 		this.headers = config.network.headers;
 		this.credentials = config.network.credentials;
-		this.retry = createRetryPolicy(config.network.retry);
+		this.readIdleTimeoutMs = config.network.readIdleTimeoutMs;
 		this.fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
 		this.now = config.now ?? (() => performance.now());
-		this.sleep = config.sleep ?? wait;
+		this.setTimer = config.setTimeout ?? ((callback, ms) => setTimeout(callback, ms));
+		this.clearTimer = config.clearTimeout ?? ((timer) => clearTimeout(timer));
 	}
 	get closed() {
 		return this.state === "closed";
@@ -204,33 +203,101 @@ var HttpFlvLoader = class {
 		return { ...this.mutableStats };
 	}
 	async open() {
-		if (this.state !== "idle") throw new HttpFlvLoaderError("RIVMUX_LOADER_INVALID_STATE", "HTTP Fetch loader can only be opened once.");
+		if (this.state !== "idle") throw new HttpFlvLoaderError("RIVMUX_LOADER_INVALID_STATE", "HTTP Fetch loader can only be opened once.", { phase: "open" });
 		this.state = "opening";
 		this.mutableStats.startedAtMs = this.now();
-		for (let attempt = 1; attempt <= this.retry.maxAttempts; attempt += 1) {
-			this.abortController = new AbortController();
-			try {
-				await this.openAttempt();
-				return;
-			} catch (cause) {
-				if (this.closed || isAbortLikeError(cause) || attempt >= this.retry.maxAttempts) throw cause;
-				await this.sleep(getRetryDelayMs(this.retry, attempt), this.abortController.signal);
-			}
+		const abortController = new AbortController();
+		this.abortController = abortController;
+		let response;
+		try {
+			response = await raceWithAbort(Promise.resolve(this.fetchImpl(this.url, {
+				method: "GET",
+				headers: createHeaders(this.headers),
+				credentials: this.credentials,
+				signal: abortController.signal
+			})), abortController.signal, (lateResponse) => void cancelResponseBody(lateResponse));
+		} catch (cause) {
+			if (this.closed || isAbortLikeError(cause)) throw cause;
+			throw new HttpFlvLoaderError("RIVMUX_HTTP_NETWORK_ERROR", "HTTP Fetch loader failed to open the stream.", {
+				phase: "open",
+				reason: "network-error",
+				cause
+			});
+		}
+		if (this.closed) {
+			await cancelResponseBody(response);
+			return;
+		}
+		if (!response.ok) {
+			await cancelResponseBody(response);
+			throw new HttpFlvLoaderError("RIVMUX_HTTP_STATUS", `HTTP Fetch loader received status ${response.status} ${response.statusText}.`, {
+				phase: "open",
+				reason: "http-status",
+				status: response.status
+			});
 		}
+		if (response.body === null) throw new HttpFlvLoaderError("RIVMUX_HTTP_BODY_UNAVAILABLE", "HTTP Fetch loader response body is unavailable.", { phase: "open" });
+		const contentLength = response.headers.get("Content-Length");
+		if (contentLength !== null) {
+			const parsedContentLength = Number.parseInt(contentLength, 10);
+			if (Number.isFinite(parsedContentLength) && parsedContentLength >= 0) this.mutableStats.contentLength = parsedContentLength;
+		}
+		try {
+			this.reader = response.body.getReader();
+		} catch (cause) {
+			await cancelResponseBody(response);
+			throw new HttpFlvLoaderError("RIVMUX_HTTP_NETWORK_ERROR", "HTTP Fetch loader could not acquire a stream reader.", {
+				phase: "open",
+				reason: "network-error",
+				cause
+			});
+		}
+		this.state = "open";
 	}
 	async read() {
 		await this.waitUntilResumed();
 		if (this.closed) return null;
 		const reader = this.reader;
-		if (reader === void 0) {
+		const abortController = this.abortController;
+		if (reader === void 0 || abortController === void 0) {
 			if (this.closed) return null;
-			throw new HttpFlvLoaderError("RIVMUX_LOADER_NOT_OPEN", "HTTP Fetch loader must be opened before read().");
+			throw new HttpFlvLoaderError("RIVMUX_LOADER_NOT_OPEN", "HTTP Fetch loader must be opened before read().", { phase: "read" });
+		}
+		const timeout = new PausableTimeout({
+			durationMs: this.readIdleTimeoutMs,
+			now: this.now,
+			setTimeout: this.setTimer,
+			clearTimeout: this.clearTimer
+		});
+		this.activeReadTimeout = timeout;
+		if (this.pausedState) timeout.pause();
+		let result;
+		try {
+			result = await raceWithAbort(Promise.race([reader.read(), timeout.promise]), abortController.signal);
+		} catch (cause) {
+			if (this.closed || isAbortLikeError(cause)) return null;
+			if (cause instanceof ReadIdleTimeoutError) throw new HttpFlvLoaderError("RIVMUX_HTTP_READ_TIMEOUT", `HTTP Fetch loader received no data for ${this.readIdleTimeoutMs} ms.`, {
+				phase: "read",
+				reason: "read-timeout",
+				cause
+			});
+			throw new HttpFlvLoaderError("RIVMUX_HTTP_READ_FAILED", "HTTP Fetch loader failed while reading the stream.", {
+				phase: "read",
+				reason: "read-error",
+				cause
+			});
+		} finally {
+			timeout.cancel();
+			if (this.activeReadTimeout === timeout) this.activeReadTimeout = void 0;
 		}
-		const result = await reader.read();
 		if (result.done) {
 			releaseReader(reader);
 			if (this.reader === reader) this.reader = void 0;
-			return null;
+			if (this.closed) return null;
+			throw new HttpFlvLoaderError("RIVMUX_HTTP_UNEXPECTED_EOF", "HTTP Fetch loader reached an unexpected end of the live stream.", {
+				phase: "read",
+				reason: "unexpected-eof"
+			});
 		}
 		const bytes = result.value;
 		const receivedAtMs = this.now();
@@ -245,12 +312,14 @@ var HttpFlvLoader = class {
 		};
 	}
 	pause() {
-		if (this.closed) return;
+		if (this.closed || this.pausedState) return;
 		this.pausedState = true;
+		this.activeReadTimeout?.pause();
 	}
 	resume() {
 		if (!this.pausedState) return;
 		this.pausedState = false;
+		this.activeReadTimeout?.resume();
 		this.resolveResumeWaiters();
 	}
 	async close() {
@@ -258,6 +327,7 @@ var HttpFlvLoader = class {
 		this.state = "closed";
 		this.pausedState = false;
 		this.resolveResumeWaiters();
+		this.activeReadTimeout?.cancel();
 		this.abortController?.abort();
 		const reader = this.reader;
 		this.reader = void 0;
@@ -268,32 +338,6 @@ var HttpFlvLoader = class {
 			releaseReader(reader);
 		}
 	}
-	async openAttempt() {
-		const abortController = this.abortController;
-		if (abortController === void 0) throw new HttpFlvLoaderError("RIVMUX_LOADER_INVALID_STATE", "HTTP Fetch loader abort controller is missing.");
-		const response = await this.fetchImpl(this.url, {
-			method: "GET",
-			headers: createHeaders(this.headers),
-			credentials: this.credentials,
-			signal: abortController.signal
-		});
-		if (this.closed) {
-			await response.body?.cancel();
-			return;
-		}
-		if (!response.ok) {
-			await response.body?.cancel();
-			throw new HttpFlvLoaderError("RIVMUX_HTTP_STATUS", `HTTP Fetch loader received status ${response.status} ${response.statusText}.`, response.status);
-		}
-		if (response.body === null) throw new HttpFlvLoaderError("RIVMUX_HTTP_BODY_UNAVAILABLE", "HTTP Fetch loader response body is unavailable.");
-		const contentLength = response.headers.get("Content-Length");
-		if (contentLength !== null) {
-			const parsedContentLength = Number.parseInt(contentLength, 10);
-			if (Number.isFinite(parsedContentLength) && parsedContentLength >= 0) this.mutableStats.contentLength = parsedContentLength;
-		}
-		this.reader = response.body.getReader();
-		this.state = "open";
-	}
 	waitUntilResumed() {
 		if (!this.pausedState || this.closed) return Promise.resolve();
 		return new Promise((resolve) => {
@@ -314,32 +358,198 @@ function createHeaders(headers) {
 	for (const [key, value] of Object.entries(headers)) result.append(key, value);
 	return result;
 }
+async function cancelResponseBody(response) {
+	try {
+		await response.body?.cancel();
+	} catch {}
+}
 function releaseReader(reader) {
 	try {
 		reader.releaseLock();
 	} catch {}
 }
-function wait(ms, signal) {
-	if (ms <= 0) return Promise.resolve();
-	if (signal.aborted) return Promise.reject(createAbortError());
+function createAbortError() {
+	return new DOMException("HTTP Fetch loader was aborted.", "AbortError");
+}
+function raceWithAbort(operation, signal, onLateValue) {
+	if (signal.aborted) {
+		operation.then(onLateValue, () => void 0);
+		return Promise.reject(createAbortError());
+	}
 	return new Promise((resolve, reject) => {
-		const cleanup = () => {
-			clearTimeout(timer);
+		let settled = false;
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
 			signal.removeEventListener("abort", onAbort);
+			operation.then(onLateValue, () => void 0);
+			reject(createAbortError());
 		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		operation.then((value) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+var ReadIdleTimeoutError = class extends Error {
+	constructor() {
+		super("HTTP Fetch loader read timed out.");
+		this.name = "ReadIdleTimeoutError";
+	}
+};
+var PausableTimeout = class {
+	promise;
+	now;
+	setTimer;
+	clearTimer;
+	reject;
+	timer;
+	remainingMs;
+	startedAtMs = 0;
+	settled = false;
+	constructor(options) {
+		this.now = options.now;
+		this.setTimer = options.setTimeout;
+		this.clearTimer = options.clearTimeout;
+		this.remainingMs = options.durationMs;
+		this.promise = new Promise((_, reject) => {
+			this.reject = reject;
+		});
+		this.start();
+	}
+	pause() {
+		if (this.settled || this.timer === void 0) return;
+		this.remainingMs = Math.max(0, this.remainingMs - Math.max(0, this.now() - this.startedAtMs));
+		this.clearTimer(this.timer);
+		this.timer = void 0;
+	}
+	resume() {
+		if (this.settled || this.timer !== void 0) return;
+		this.start();
+	}
+	cancel() {
+		if (this.settled) return;
+		this.settled = true;
+		if (this.timer !== void 0) {
+			this.clearTimer(this.timer);
+			this.timer = void 0;
+		}
+		this.reject = void 0;
+	}
+	start() {
+		this.startedAtMs = this.now();
+		this.timer = this.setTimer(() => {
+			if (this.settled) return;
+			this.settled = true;
+			this.timer = void 0;
+			this.reject?.(new ReadIdleTimeoutError());
+			this.reject = void 0;
+		}, this.remainingMs);
+	}
+};
+//#endregion
+//#region src/loader/retry-policy.ts
+/**
+* Calculates the delay after a failed one-based connection attempt.
+* Attempt 1 is the initial connection, so its retry uses the base delay.
+*/
+function getRetryDelayMs(policy, failedAttempt, random = Math.random) {
+	if (policy.backoffMs === 0 || policy.maxBackoffMs === 0) return 0;
+	const exponent = Math.max(0, Math.trunc(failedAttempt) - 1);
+	const exponentialDelay = Math.min(policy.maxBackoffMs, policy.backoffMs * 2 ** exponent);
+	const jitterMultiplier = 1 + (normalizeRandom(random()) * 2 - 1) * policy.jitterRatio;
+	return Math.min(policy.maxBackoffMs, Math.max(0, Math.round(exponentialDelay * jitterMultiplier)));
+}
+function isRecoverableHttpStatus(status) {
+	return status === 408 || status === 429 || status >= 500 && status <= 599;
+}
+function isRecoverableLoaderError(cause) {
+	if (!(cause instanceof HttpFlvLoaderError) || cause.reason === void 0) return false;
+	if (cause.reason === "http-status") return cause.status !== void 0 && isRecoverableHttpStatus(cause.status);
+	return cause.reason === "network-error" || cause.reason === "read-error" || cause.reason === "read-timeout" || cause.reason === "unexpected-eof";
+}
+function normalizeRandom(value) {
+	if (!Number.isFinite(value)) return .5;
+	return Math.min(1, Math.max(0, value));
+}
+//#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 = () => {
-			cleanup();
-			reject(createAbortError());
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			operation.then(onLateValue, () => void 0);
+			resolve({ cancelled: true });
 		};
-		const timer = setTimeout(() => {
-			cleanup();
-			resolve();
-		}, ms);
 		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);
+		});
 	});
 }
-function createAbortError() {
-	return new DOMException("HTTP Fetch loader was aborted.", "AbortError");
+//#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/mse/mime.ts
@@ -349,25 +559,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 +728,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 +743,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 +887,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 +1048,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 +1063,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);
@@ -885,44 +1079,50 @@ function __wbg_get_imports() {
 		__proto__: null,
 		"./rivmux_transmux_core_bg.js": {
 			__proto__: null,
-			__wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
-				return addHeapObject(Error(getStringFromWasm0(arg0, arg1)));
+			__wbg_Error_67e7344beaa85059: function(arg0, arg1) {
+				return Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbg_Number_c54e7112a3fa7e3e: 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);
 			},
-			__wbg___wbindgen_throw_ea4887a5f8f9a9db: function(arg0, arg1) {
+			__wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
 				throw new Error(getStringFromWasm0(arg0, arg1));
 			},
-			__wbg_new_2e117a478906f062: function() {
-				return addHeapObject(/* @__PURE__ */ new Object());
-			},
-			__wbg_new_36e147a8ced3c6e0: function() {
-				return addHeapObject(new Array());
+			__wbg_new_bebc3f4757acf305: function() {
+				return /* @__PURE__ */ new Object();
 			},
-			__wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
-				getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+			__wbg_new_ffa92086ea89f79c: function() {
+				return new Array();
 			},
-			__wbg_set_dc601f4a69da0bc2: function(arg0, arg1, arg2) {
-				getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+			__wbg_set_13d25b81ab403f5e: function(arg0, arg1, arg2) {
+				arg0[arg1 >>> 0] = arg2;
 			},
-			__wbindgen_cast_0000000000000001: function(arg0) {
-				return addHeapObject(arg0);
+			__wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+				arg0[arg1] = arg2;
 			},
-			__wbindgen_cast_0000000000000002: function(arg0) {
-				return addHeapObject(arg0);
+			__wbindgen_generic_0000000000000001: function(arg0) {
+				return arg0;
 			},
-			__wbindgen_cast_0000000000000003: function(arg0, arg1) {
-				return addHeapObject(getStringFromWasm0(arg0, arg1));
+			__wbindgen_generic_0000000000000002: function(arg0) {
+				return arg0;
 			},
-			__wbindgen_object_clone_ref: function(arg0) {
-				return addHeapObject(getObject(arg0));
+			__wbindgen_generic_0000000000000003: function(arg0, arg1) {
+				return getStringFromWasm0(arg0, arg1);
 			},
-			__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 +1131,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 +1144,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 +1178,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,14 +1217,16 @@ 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 (!module.ok) throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
 		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);
+			if (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();
@@ -1066,8 +1250,10 @@ async function __wbg_load(module, imports) {
 }
 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) {
+		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);
@@ -1084,41 +1270,494 @@ 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) {
+					if (this.isCurrentLoader(loader, runId) && this.isLifecycleContextCurrent(context)) {
+						if (!await this.appendController.flush(context)) return;
+						this.dependencies.onStats(loader.stats);
+					}
+					return;
+				}
+				if (!this.isCurrentLoader(loader, runId) || !this.isLifecycleContextCurrent(context)) return;
+				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);
+			}
+		} catch (cause) {
+			if (!this.isCurrentLoader(loader, runId) || isAbortLikeError(cause)) return;
+			try {
+				await this.closeCurrentLoader(loader, runId);
+			} catch {}
+			if (!this.isLifecycleContextCurrent(context)) return;
+			if (isRecoverableLoaderError(cause)) {
+				this.dependencies.onRecoverableFailure(cause, 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;
+				}
+			}
+		}
+		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;
+	sleep;
+	random;
 	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();
+	recoveryPromise;
+	connectionAttempt = 1;
+	recoveryStartedAt;
+	pendingRecovery;
 	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.sleep = dependencies.sleep ?? waitForDelay;
+		this.random = dependencies.random ?? Math.random;
+		this.session = new RuntimeSession({
+			...dependencies,
+			isStarted: () => this.state === "started",
+			isLifecycleContextCurrent: (context) => this.isLifecycleContextCurrent(context),
+			onMediaAppended: async (context) => {
+				this.markRecovered(context);
+				await 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),
+			onRecoverableFailure: (cause, context) => this.scheduleRecovery(cause, context),
+			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,22 +1775,17 @@ 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();
 					return;
-				case "update-options":
-					this.options = this.options === void 0 ? void 0 : mergeOptions(this.options, command.options);
-					if (this.options !== void 0) this.latencyController = createLatencyController(this.options);
-					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,267 +1798,245 @@ 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;
+		if (this.state === "started") {
+			this.post({ type: "started" });
+			return;
+		}
 		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();
+		if (!this.startLoader(context)) return;
+		if (!this.isLifecycleContextCurrent(context) || this.state !== "started") return;
+		this.post({ type: "started" });
 	}
 	async stop() {
+		await this.waitForRecovery();
 		await this.closeLoader();
-		this.mse?.destroy();
-		this.mse = void 0;
+		this.session.destroyMse();
 		this.latencyController?.reset();
 		this.videoState = void 0;
 		this.lastLatencyMetrics = {};
+		this.resetRecoveryCycle();
 		this.state = "stopped";
 		this.post({ type: "stopped" });
 	}
 	async destroy() {
+		await this.fatalCleanupPromise;
+		await this.waitForRecovery();
 		await this.closeLoader();
-		this.mse?.destroy();
-		this.mse = void 0;
+		this.session.destroyMse();
 		this.latencyController?.reset();
 		this.videoState = void 0;
 		this.lastLatencyMetrics = {};
+		this.resetRecoveryCycle();
 		this.state = "destroyed";
 		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;
+			return false;
 		}
-		const loader = this.createLoader({
+		this.session.runLoader({
 			url,
 			network: options.network
+		}, context);
+		return true;
+	}
+	async closeLoader() {
+		this.stopStatsTimer();
+		await this.session.close();
+	}
+	scheduleRecovery(cause, context) {
+		if (!this.isLifecycleContextCurrent(context) || this.state !== "started" || this.recoveryPromise !== void 0) return;
+		const recovery = this.recover(cause, context).finally(() => {
+			if (this.recoveryPromise === recovery) this.recoveryPromise = void 0;
 		});
-		const runId = this.loaderRunId + 1;
-		this.loaderRunId = runId;
-		this.loader = loader;
-		this.runLoader(loader, runId);
+		this.recoveryPromise = recovery;
 	}
-	async runLoader(loader, runId) {
+	async recover(cause, context) {
+		const options = this.options;
+		if (options === void 0 || !this.isLifecycleContextCurrent(context) || this.state !== "started") return;
+		this.recoveryStartedAt ??= this.now();
+		if (this.connectionAttempt >= options.network.retry.maxAttempts) {
+			this.fail("network", "RIVMUX_RECONNECT_EXHAUSTED", "Live stream reconnect attempts were exhausted.", true, cause);
+			return;
+		}
+		const failedAttempt = this.connectionAttempt;
+		const attempt = failedAttempt + 1;
+		this.connectionAttempt = attempt;
+		const delayMs = getRetryDelayMs(options.network.retry, failedAttempt, this.random);
+		this.post({
+			type: "reconnecting",
+			info: {
+				attempt,
+				maxAttempts: options.network.retry.maxAttempts,
+				delayMs,
+				reason: cause.reason ?? "network-error"
+			}
+		});
+		await this.closeLoader();
+		this.session.destroyMse();
+		this.latencyController?.reset();
+		this.lastLatencyMetrics = {};
+		if (!this.isLifecycleContextCurrent(context) || this.state !== "started") return;
 		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);
+			if ((await raceLifecycleOperation(this.sleep(delayMs, context.signal), context.signal)).cancelled || !this.isLifecycleContextCurrent(context) || this.state !== "started") return;
+		} catch (delayError) {
+			if (this.isLifecycleContextCurrent(context)) this.fail("network", "RIVMUX_RECONNECT_DELAY_FAILED", "Live stream reconnect delay failed.", true, delayError);
+			return;
+		}
+		let handle;
+		try {
+			handle = await this.session.attach(context);
+		} catch (attachError) {
+			if (this.isLifecycleContextCurrent(context)) this.fail("mse", "RIVMUX_MSE_ATTACH_FAILED", "MSE media source attachment failed during reconnect.", true, attachError);
+			return;
+		}
+		if (handle === void 0 || !this.isLifecycleContextCurrent(context) || this.state !== "started") return;
+		this.post({
+			type: "media-source-handle",
+			handle
+		}, [handle]);
+		try {
+			const core = await this.session.createCore(options, context);
+			if (!this.isLifecycleContextCurrent(context) || this.state !== "started") return;
+			if (core === void 0) {
+				this.fail("runtime", "RIVMUX_TRANSMUX_CORE_UNAVAILABLE", "Transmux core is not available during reconnect.", true);
+				return;
 			}
-		} 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);
+			this.session.start(core, context);
+		} catch (coreError) {
+			if (this.isLifecycleContextCurrent(context)) this.fail("runtime", "RIVMUX_TRANSMUX_CORE_UNAVAILABLE", "Transmux core is not available during reconnect.", true, coreError);
 			return;
-		} finally {
-			if (this.isCurrentLoader(loader, runId)) await this.closeCurrentLoader(loader, runId);
 		}
+		this.pendingRecovery = {
+			attempt,
+			downtimeMs: 0
+		};
+		this.appendQueueMaxLength = 0;
+		this.appendQueueMaxBytes = 0;
+		this.startStatsTimer();
+		this.postStats();
+		this.recoveryPromise = void 0;
+		this.startLoader(context);
+	}
+	markRecovered(context) {
+		const recovery = this.pendingRecovery;
+		const startedAt = this.recoveryStartedAt;
+		if (recovery === void 0 || startedAt === void 0 || !this.isLifecycleContextCurrent(context) || this.state !== "started") return;
+		this.pendingRecovery = void 0;
+		this.recoveryStartedAt = void 0;
+		this.connectionAttempt = 1;
+		this.post({
+			type: "recovered",
+			info: {
+				attempt: recovery.attempt,
+				downtimeMs: Math.max(0, this.now() - startedAt)
+			}
+		});
 	}
-	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();
+	async waitForRecovery() {
+		try {
+			await this.recoveryPromise;
+		} catch {}
 	}
-	isCurrentLoader(loader, runId) {
-		return this.loader === loader && this.loaderRunId === runId && this.state === "started";
+	resetRecoveryCycle() {
+		this.connectionAttempt = 1;
+		this.recoveryStartedAt = void 0;
+		this.pendingRecovery = void 0;
 	}
 	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 +2059,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 +2094,7 @@ var RuntimeWorker = class {
 		this.failWithError(error);
 	}
 	failWithError(error) {
+		if (this.state === "destroyed") return;
 		if (error.terminal) this.enterFatalErrorState();
 		this.post({
 			type: "error",
@@ -1479,39 +2102,61 @@ 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 = {};
+		this.resetRecoveryCycle();
 	}
 	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 waitForDelay(delayMs, signal) {
+	if (delayMs <= 0) return Promise.resolve();
+	if (signal.aborted) return Promise.reject(new DOMException("Reconnect delay was aborted.", "AbortError"));
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(new DOMException("Reconnect delay was aborted.", "AbortError"));
+		};
+		const timer = setTimeout(() => {
+			cleanup();
+			resolve();
+		}, delayMs);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
 }
 function serializeCause(cause) {
 	if (cause instanceof Error) return {
 		name: cause.name,
 		message: cause.message
 	};
-	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;
+	if (typeof cause === "object" && cause !== null) {
+		const value = cause;
+		return {
+			name: typeof value.name === "string" ? value.name : "Error",
+			message: typeof value.message === "string" ? value.message : String(cause)
+		};
+	}
+	return {
+		name: "Error",
+		message: String(cause)
+	};
 }
 function detectWorkerRuntime() {
 	if (typeof fetch !== "function") return createUnsupportedRuntimeError("RIVMUX_UNSUPPORTED_FETCH", "Fetch is not available in this worker runtime.");
@@ -1520,7 +2165,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 +2180,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) {