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

package/dist/rivmux-runtime-worker.js

@@ -141,151 +141,44 @@ 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 {
-		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
@@ -294,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";
@@ -309,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();
@@ -350,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() {
@@ -363,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;
@@ -373,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) => {
@@ -419,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
@@ -974,10 +1079,10 @@ function __wbg_get_imports() {
 		__proto__: null,
 		"./rivmux_transmux_core_bg.js": {
 			__proto__: null,
-			__wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
+			__wbg_Error_67e7344beaa85059: function(arg0, arg1) {
 				return Error(getStringFromWasm0(arg0, arg1));
 			},
-			__wbg_Number_c4bdf66bb78f7977: function(arg0) {
+			__wbg_Number_c54e7112a3fa7e3e: function(arg0) {
 				return Number(arg0);
 			},
 			__wbg_String_8564e559799eccda: function(arg0, arg1) {
@@ -986,28 +1091,28 @@ function __wbg_get_imports() {
 				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() {
+			__wbg_new_bebc3f4757acf305: function() {
 				return /* @__PURE__ */ new Object();
 			},
-			__wbg_new_36e147a8ced3c6e0: function() {
+			__wbg_new_ffa92086ea89f79c: function() {
 				return new Array();
 			},
+			__wbg_set_13d25b81ab403f5e: function(arg0, arg1, arg2) {
+				arg0[arg1 >>> 0] = arg2;
+			},
 			__wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
 				arg0[arg1] = arg2;
 			},
-			__wbg_set_dc601f4a69da0bc2: function(arg0, arg1, arg2) {
-				arg0[arg1 >>> 0] = arg2;
-			},
-			__wbindgen_cast_0000000000000001: function(arg0) {
+			__wbindgen_generic_0000000000000001: function(arg0) {
 				return arg0;
 			},
-			__wbindgen_cast_0000000000000002: function(arg0) {
+			__wbindgen_generic_0000000000000002: function(arg0) {
 				return arg0;
 			},
-			__wbindgen_cast_0000000000000003: function(arg0, arg1) {
+			__wbindgen_generic_0000000000000003: function(arg0, arg1) {
 				return getStringFromWasm0(arg0, arg1);
 			},
 			__wbindgen_init_externref_table: function() {
@@ -1117,10 +1222,11 @@ function __wbg_finalize_init(instance, module) {
 }
 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();
@@ -1144,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);
@@ -1470,7 +1578,14 @@ var RuntimeSession = class {
 				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;
+				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);
@@ -1480,16 +1595,16 @@ var RuntimeSession = class {
 				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;
+			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 {
@@ -1531,11 +1646,6 @@ var RuntimeSession = class {
 					if (append !== void 0 && !await append) return false;
 					break;
 				}
-				case "probeResult":
-				case "trackConfig":
-				case "sample":
-				case "metadata":
-				case "discontinuity": break;
 			}
 		}
 		return this.appendController.waitForTail();
@@ -1583,6 +1693,8 @@ var RuntimeWorker = class {
 	port;
 	detectRuntime;
 	now;
+	sleep;
+	random;
 	state = "idle";
 	url;
 	options;
@@ -1598,21 +1710,31 @@ var RuntimeWorker = class {
 	lifecycleGeneration = 0;
 	lifecycleAbortController = new AbortController();
 	fatalCleanupPromise = Promise.resolve();
+	recoveryPromise;
+	connectionAttempt = 1;
+	recoveryStartedAt;
+	pendingRecovery;
 	constructor(port, dependencies = {}) {
 		this.port = port;
 		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: (context) => this.applyLatencyPolicy(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),
@@ -1661,10 +1783,6 @@ var RuntimeWorker = class {
 				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;
 					if (!(await raceLifecycleOperation(this.applyLatencyPolicy(context), context.signal)).cancelled && this.isLifecycleContextCurrent(context) && this.state === "started") this.postStats();
@@ -1704,7 +1822,10 @@ var RuntimeWorker = class {
 			this.fail("runtime", "RIVMUX_WORKER_START_REQUIRES_ATTACH", "Worker start requires an attached MediaSource.", true);
 			return;
 		}
-		if (this.state === "started") return;
+		if (this.state === "started") {
+			this.post({ type: "started" });
+			return;
+		}
 		try {
 			const transmuxCore = await this.session.createCore(options, context);
 			if (context.generation !== this.lifecycleGeneration) return;
@@ -1724,24 +1845,30 @@ var RuntimeWorker = class {
 		if ((await raceLifecycleOperation(this.applyLatencyPolicy(context), context.signal)).cancelled || !this.isLifecycleContextCurrent(context)) return;
 		this.startStatsTimer();
 		this.postStats();
-		this.startLoader(context);
+		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.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.session.destroyMse();
 		this.latencyController?.reset();
 		this.videoState = void 0;
 		this.lastLatencyMetrics = {};
+		this.resetRecoveryCycle();
 		this.state = "destroyed";
 		this.post({ type: "destroyed" });
 		this.port.close();
@@ -1751,17 +1878,117 @@ var RuntimeWorker = class {
 		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;
 		}
 		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;
+		});
+		this.recoveryPromise = recovery;
+	}
+	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 {
+			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;
+			}
+			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;
+		}
+		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 waitForRecovery() {
+		try {
+			await this.recoveryPromise;
+		} catch {}
+	}
+	resetRecoveryCycle() {
+		this.connectionAttempt = 1;
+		this.recoveryStartedAt = void 0;
+		this.pendingRecovery = void 0;
+	}
 	postStats(loaderStats) {
 		const mseStats = this.collectMseStats();
 		const loaderSnapshot = loaderStats ?? this.session.loaderStats;
@@ -1884,6 +2111,7 @@ var RuntimeWorker = class {
 		this.latencyController?.reset();
 		this.videoState = void 0;
 		this.lastLatencyMetrics = {};
+		this.resetRecoveryCycle();
 	}
 	post(message, transfer) {
 		this.port.postMessage(message, transfer);
@@ -1894,12 +2122,41 @@ var RuntimeWorker = class {
 		this.lifecycleAbortController = new AbortController();
 	}
 };
+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;
+	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.");