@statewalker/webrun-http-browser 0.3.2 → 0.3.4

package/dist/sw-worker.js

@@ -0,0 +1,813 @@
+(function() {
+	//#region ../webrun-http-streams/src/bytes.ts
+	function toAsyncIterator(input) {
+		const asyncIter = input[Symbol.asyncIterator];
+		if (asyncIter) return asyncIter.call(input);
+		const syncIter = input[Symbol.iterator]();
+		return { next() {
+			return Promise.resolve(syncIter.next());
+		} };
+	}
+	/**
+	* Discard an iterable we are contractually forbidden from consuming — a body
+	* skipped for HEAD/204, or one abandoned because the peer reported an error.
+	*
+	* The `.next()` is not optional: `.return()` on a generator still in suspended
+	* start is a no-op, so the body never runs and its `try/finally` never unwinds.
+	* Without it a wrapped ReadableStream or socket is never cancelled.
+	*/
+	async function discard(source) {
+		if (source === void 0) return;
+		const it = toAsyncIterator(source);
+		try {
+			await it.next();
+			await it.return?.();
+		} catch {}
+	}
+	//#endregion
+	//#region ../webrun-streams/src/errors.ts
+	function serializeError(error) {
+		if (error instanceof Error) {
+			const out = {
+				message: error.message,
+				stack: error.stack
+			};
+			const bag = error;
+			for (const key of Object.keys(bag)) out[key] = bag[key];
+			return out;
+		}
+		if (typeof error === "object" && error !== null) {
+			const bag = error;
+			return {
+				message: String(bag.message ?? error),
+				...bag
+			};
+		}
+		return { message: String(error) };
+	}
+	function deserializeError(error) {
+		const payload = typeof error === "string" ? { message: error } : error;
+		return Object.assign(new Error(payload.message), payload);
+	}
+	//#endregion
+	//#region ../webrun-streams/src/new-async-generator.ts
+	/**
+	* The newAsyncGenerator function creates async generators from callback-based initialization
+	* functions, providing a bridge between imperative event handling and declarative async
+	* iteration patterns.
+	*
+	* The initialization function receives two callback functions that control the generator's
+	* behavior. The `next` function yields values to consumers, while the `done` function
+	* signals completion or error conditions. The initialization function can return a cleanup
+	* function that will be called when the generator is closed or an error occurs.
+	*
+	* The generator manages an internal queue of values and completion signals, ensuring that
+	* producers can yield values without overwhelming consumers. Proper backpressure is implemented
+	* by having the `next` and `done` functions return promises that resolve only after the
+	* consumer has processed the values. This prevents memory leaks and ensures that producers
+	* are aware of whether their values were successfully handled.
+	* The generator also handles cleanup by draining any remaining items in the queue and notifying
+	* producers that their values were not processed if the generator is closed early. This ensures
+	* that resources are properly managed and that no memory leaks occur.
+	*
+	* Example usage:
+	* ```typescript
+	* const asyncGen = newAsyncGenerator<number>((next, done) => {
+	*   let count = 0;
+	*   const interval = setInterval(() => {
+	*     if (count < 5) {
+	*       next(count++);
+	*     } else {
+	*       done();
+	*       clearInterval(interval);
+	*     }
+	*   }, 1000);
+	*   return () => clearInterval(interval); // Cleanup function
+	* });
+	* (async () => {
+	*   for await (const num of asyncGen) {
+	*     console.log(num); // Logs numbers 0 to 4 at 1 second intervals
+	*   }
+	*   console.log("Completed");
+	* })();
+	* ```
+	* @template T The type of values yielded by the generator
+	* @template E The type of errors that can be thrown; defaults to Error
+	* @param init Initialization function that sets up the generator behavior with next/done callbacks;
+	*  The first parameter - `next` function - is used to yield values to consumers;
+	*  It returns a Promise<boolean> indicating whether the value was successfully handled;
+	*  The second parameter - `done` function - is used to signal completion or error;
+	*  It returns a Promise<boolean> indicating whether the completion was successfully handled;
+	*  The initialization function can optionally return a cleanup function that will be called
+	*  when the generator is closed or an error occurs;
+	* @param skipValues If true, only the most recent value is kept in the queue,
+	* skipping intermediate values (not consumed values are considered skipped);
+	* This is useful for scenarios where only the latest value matters, such as UI updates.
+	* Defaults to false, meaning all values are queued and processed in order.
+	* @returns AsyncGenerator that properly manages backpressure and resource cleanup
+	*/
+	async function* newAsyncGenerator(init, skipValues = false) {
+		let head;
+		let tail;
+		/** Flag to prevent new values from being queued after generator closes */
+		let closed = false;
+		/** Wake-up function to notify the generator loop of new items */
+		let wakeUp;
+		/**
+		* Drains the internal queue, notifying all pending producers that their values
+		* were not processed due to generator closure. This prevents memory leaks and
+		* ensures proper backpressure signaling.
+		*/
+		const drainQueue = () => {
+			for (; head; head = head.next) {
+				closed = closed || head.done;
+				head.resolve(false);
+			}
+			tail = void 0;
+		};
+		/**
+		* Enqueues a value or completion signal with a promise that resolves when the item
+		* is processed. This enables backpressure by allowing producers to know when their
+		* values have been consumed.
+		*/
+		const enqueue = (params) => {
+			if (skipValues) drainQueue();
+			return !closed ? new Promise((resolve) => {
+				const next = {
+					...params,
+					next: void 0,
+					resolve
+				};
+				if (tail) tail.next = next;
+				tail = next;
+				if (!head) head = tail;
+				wakeUp?.();
+			}) : Promise.resolve(false);
+		};
+		/**
+		* Producer function to yield a value to consumers. Returns a promise that resolves
+		* to true if the value was successfully processed, false if the generator is closed
+		* or the value was skipped due to backpressure.
+		*/
+		const next = (value) => enqueue({
+			done: false,
+			value
+		});
+		/**
+		* Producer function to signal completion or error. Optional error parameter will
+		* cause the generator to throw that error to consumers.
+		*/
+		const done = (error) => enqueue({
+			done: true,
+			error
+		});
+		const unsubscribe = init(next, done);
+		try {
+			while (!closed) {
+				if (!head) {
+					await new Promise((resolve) => {
+						wakeUp = resolve;
+					}).then(() => {
+						wakeUp = void 0;
+					});
+					continue;
+				}
+				const slot = head;
+				head = head.next;
+				if (tail === slot) tail = head;
+				try {
+					if (slot.done) {
+						closed = true;
+						if (slot.error !== void 0) throw slot.error;
+						break;
+					}
+					yield slot.value;
+				} finally {
+					slot.resolve(true);
+				}
+			}
+		} finally {
+			/**
+			* Cleanup phase - ensures proper resource management and notification of any
+			* remaining producers. This runs whether the generator completes normally,
+			* encounters an error, or is closed early by the consumer.
+			*/
+			closed = true;
+			wakeUp?.();
+			if (typeof unsubscribe === "function") await unsubscribe();
+			/**
+			* Drain any remaining items in the queue and notify their producers that
+			* the values were not processed. This prevents memory leaks and ensures
+			* proper backpressure signaling.
+			*/
+			drainQueue();
+		}
+	}
+	//#endregion
+	//#region ../webrun-streams/src/readable-streams.ts
+	function toReadableStream(it) {
+		return new ReadableStream({ async pull(controller) {
+			let handled = false;
+			try {
+				while (true) {
+					const slot = await it.next();
+					if (!slot || slot.done) break;
+					const value = await slot.value;
+					controller.enqueue(value);
+				}
+			} catch (error) {
+				handled = true;
+				controller.error(error);
+			} finally {
+				if (!handled) controller.close();
+			}
+		} });
+	}
+	async function* fromReadableStream(stream) {
+		const reader = stream.getReader();
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value !== void 0) yield value;
+		}
+	}
+	//#endregion
+	//#region ../webrun-streams/src/recieve-iterator.ts
+	/**
+	* Inverse of {@link sendIterator}: turns a sequence of `{done, value, error}`
+	* chunks (delivered to the supplied callback by `installer`) into an async
+	* generator.
+	*
+	* The `installer` is given a `deliver` function. It should call `deliver`
+	* once for each incoming chunk and may return a cleanup callback that
+	* runs when the consumer stops iterating.
+	*/
+	function recieveIterator(installer) {
+		return newAsyncGenerator((next, done) => {
+			const cleanup = installer(async (chunk = { done: true }) => {
+				const { done: isDone = true, value, error } = chunk;
+				if (error) return await done(error);
+				if (isDone) return await done();
+				return await next(value);
+			});
+			if (cleanup) return async () => {
+				await cleanup();
+			};
+		});
+	}
+	//#endregion
+	//#region ../webrun-streams/src/send-iterator.ts
+	/**
+	* Drain an async iterator into a sink that consumes one chunk at a time.
+	*
+	* Each yielded value becomes `{ done: false, value }`. Completion emits
+	* `{ done: true }`. If the iterator throws, the error is caught and the
+	* final `done` chunk carries it so the peer can rethrow on its side.
+	*/
+	async function sendIterator(send, it) {
+		let error;
+		try {
+			for await (const value of it) await send({
+				done: false,
+				value
+			});
+		} catch (err) {
+			error = err;
+		} finally {
+			await send({
+				done: true,
+				error
+			});
+		}
+	}
+	//#endregion
+	//#region ../webrun-http-streams/src/request-streams.ts
+	/**
+	* The one place that knows a runtime may not implement request body streams,
+	* and the buffering both fallbacks need. `fetch.ts` and `http-stubs.ts` each
+	* carry a client and a server direction that must agree on the answer, so the
+	* predicate lives here rather than being written out four times.
+	*/
+	/**
+	* Whether `Request.prototype` exposes a `body` accessor. Two call sites read
+	* that property, and two more depend on the constructor accepting a
+	* `ReadableStream` as `init.body`; this predicate answers for all four.
+	*
+	* What was verified, and all that is claimed here: Firefox (146 at the time of
+	* writing) has *neither*, and Chromium and Node have *both*. On Firefox it is
+	* not that `body` is `undefined` on the instance —
+	* `Object.getOwnPropertyDescriptor(Request.prototype, "body")` is `null`, the
+	* accessor is genuinely absent — and because a `ReadableStream` is then not a
+	* recognised `BodyInit`, the constructor falls through to the string branch and
+	* stores the literal text `[object ReadableStream]`.
+	*
+	* The two halves are NOT guaranteed to ship together, so do not read this as a
+	* test for "request streams" in general. Safari is the counterexample: it has
+	* had `Request.body` since 11.1 but only accepts a stream as `init.body` from
+	* Technology Preview 250, so a shipping Safari has the reader half without the
+	* upload half and this returns `true` there. That looks benign — WebKit appears
+	* to store the stream on the `Request` rather than stringify it, and its error
+	* comes from `fetch()`, which this package never calls on the objects it builds
+	* — but it is untested, and it is the case to look at first if a Safari report
+	* arrives. The sharper probe, if one is ever needed, is whether
+	* `new Request(url, {method:"POST", body:new ReadableStream(), duplex:"half"})`
+	* has a `content-type` of `text/plain;charset=UTF-8` (stringified) or `null`
+	* (stored); it is not used here because it costs a `Request` and a
+	* `ReadableStream` per call and agrees with the descriptor check on every
+	* runtime measured.
+	*
+	* A capability check, never a user-agent test: the question is what this
+	* runtime does, and the answer flips on its own the day Firefox ships request
+	* streams. Evaluated per call rather than cached at module load so that a test
+	* can install a `Request` without the capability and exercise the real branch
+	* under Node.
+	*/
+	function supportsRequestStreams() {
+		return typeof Request === "function" && Object.getOwnPropertyDescriptor(Request.prototype, "body") != null;
+	}
+	//#endregion
+	//#region ../webrun-http-streams/src/http-stubs.ts
+	const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+		101,
+		103,
+		204,
+		205,
+		304
+	]);
+	const REQUEST_FIELDS = [
+		"url",
+		"method",
+		"mode",
+		"credentials",
+		"cache",
+		"redirect",
+		"referrer",
+		"referrerPolicy",
+		"integrity",
+		"keepalive"
+	];
+	/** `SerializedHttpEnvelope.content` is never absent, only empty. */
+	async function* noBytes() {}
+	async function* oneChunk(chunk) {
+		yield chunk;
+	}
+	/**
+	* Returns an HTTP handler that serializes a Request, hands the envelope to
+	* `send` for transport, and deserializes the reply into a Response. Used on
+	* the caller side.
+	*/
+	function newHttpClientStub(send) {
+		return async (requestOrPromise) => {
+			const request = await requestOrPromise;
+			const headers = [...request.headers].map(([k, v]) => [k, v]);
+			const options = {
+				url: request.url,
+				headers
+			};
+			for (const field of REQUEST_FIELDS) {
+				const val = request[field];
+				if (val !== void 0 && field !== "url") options[field] = val;
+			}
+			let content;
+			if (request.body != null) content = fromReadableStream(request.body);
+			else if (!supportsRequestStreams()) content = oneChunk(new Uint8Array(await request.arrayBuffer()));
+			else content = noBytes();
+			const result = await send({
+				options,
+				content
+			});
+			if (!result) return new Response(null, {
+				status: 404,
+				statusText: "Error 404: Not Found"
+			});
+			const responseOptions = result.options;
+			const method = options.method;
+			if (method === "HEAD" || method === "OPTIONS" || NULL_BODY_STATUSES.has(responseOptions.status)) {
+				await discard(result.content);
+				return new Response(null, responseOptions);
+			}
+			return new Response(toReadableStream(result.content[Symbol.asyncIterator]()), responseOptions);
+		};
+	}
+	//#endregion
+	//#region src/core/data-channels.ts
+	const MESSAGE_TYPE_REQUEST = "REQUEST";
+	const MESSAGE_TYPE_RESPONSE = "RESPONSE";
+	let __invocationCounter = 0;
+	function newInvokationChannel({ port, handler = () => {
+		throw new Error("Handler not implemented");
+	}, onError = console.error, newCallId = () => ++__invocationCounter }) {
+		const requests = {};
+		const listener = async (event) => {
+			const data = event.data ?? {};
+			if (data.type === MESSAGE_TYPE_REQUEST) try {
+				const result = await handler(data.request, ...event.ports);
+				const [response, ...transfers] = Array.isArray(result) ? result : result !== void 0 ? [result] : [];
+				port.postMessage({
+					type: MESSAGE_TYPE_RESPONSE,
+					callId: data.callId,
+					response
+				}, transfers);
+			} catch (error) {
+				port.postMessage({
+					type: MESSAGE_TYPE_RESPONSE,
+					callId: data.callId,
+					error: serializeError(error)
+				});
+			}
+			else if (data.type === MESSAGE_TYPE_RESPONSE) {
+				const pending = requests[data.callId];
+				delete requests[data.callId];
+				if (!pending) return;
+				if (data.error) pending.reject(deserializeError(data.error));
+				else pending.resolve(data.response);
+			}
+		};
+		const start = async () => {
+			try {
+				port.addEventListener("message", listener);
+				await port.start?.();
+			} catch (e) {
+				onError(e);
+			}
+		};
+		const close = async () => {
+			try {
+				port.removeEventListener("message", listener);
+				await port.close?.();
+			} catch (e) {
+				onError(e);
+			}
+		};
+		const invoke = (request = {}, ...transfers) => {
+			const callId = newCallId();
+			return new Promise((resolve, reject) => {
+				try {
+					requests[callId] = {
+						resolve,
+						reject
+					};
+					port.postMessage({
+						type: MESSAGE_TYPE_REQUEST,
+						callId,
+						request
+					}, transfers);
+				} catch (error) {
+					delete requests[callId];
+					reject(error);
+				}
+			});
+		};
+		return {
+			start,
+			close,
+			invoke
+		};
+	}
+	async function* sendStream(communicationPort, input, params = {}) {
+		const messageChannel = new MessageChannel();
+		communicationPort.postMessage({
+			type: "START_CALL",
+			params
+		}, [messageChannel.port2]);
+		const channel = newStreamChannel(messageChannel.port1);
+		try {
+			await channel.start();
+			channel.sendAll(input);
+			yield* channel.recieveAll();
+		} finally {
+			await channel.close();
+		}
+	}
+	function newStreamChannel(port) {
+		let listeners = [];
+		let iterators = [];
+		const notifyAll = async (data) => {
+			for (const listener of listeners) await listener(data);
+		};
+		const channel = newInvokationChannel({
+			port,
+			handler: (data) => notifyAll(data)
+		});
+		const start = () => channel.start();
+		const close = async () => {
+			await notifyAll({ done: true });
+			for (const it of [...iterators]) await it.return?.();
+			await channel.close();
+		};
+		async function* recieveAll() {
+			yield* recieveIterator((deliver) => {
+				listeners.push(deliver);
+				return () => {
+					listeners = listeners.filter((l) => l !== deliver);
+				};
+			});
+		}
+		async function sendAll(it) {
+			await sendIterator((chunk) => void channel.invoke(chunk), (async function* () {
+				try {
+					iterators.push(it);
+					yield* it;
+				} finally {
+					iterators = iterators.filter((i) => i !== it);
+				}
+			})());
+		}
+		return {
+			start,
+			close,
+			recieveAll,
+			sendAll
+		};
+	}
+	//#endregion
+	//#region src/http/http-send-recieve.ts
+	async function* httpToIterator(envelopeOrPromise) {
+		const { options, content } = await envelopeOrPromise;
+		yield new TextEncoder().encode(JSON.stringify(options));
+		yield* content;
+	}
+	async function httpFromIterator(iterable) {
+		const it = (await iterable)[Symbol.asyncIterator]();
+		const { done, value } = await it.next();
+		let options = {};
+		if (!done && value) {
+			const str = new TextDecoder().decode(value);
+			options = JSON.parse(str);
+		}
+		return {
+			options,
+			content: { [Symbol.asyncIterator]() {
+				return it;
+			} }
+		};
+	}
+	/**
+	* @deprecated For new code, prefer the `MessagePort`-based stack from
+	* `@statewalker/webrun-http-port/fetch`. Once the page and SW share a
+	* `MessagePort`, `fetchOverPort(port, request)` provides the same
+	* `Request → Response` semantics with multiplexing via `callBidi`, JSONL
+	* envelope framing, and native `AbortSignal` support. This helper remains for
+	* existing ServiceWorker setups; it will be reimplemented on top of
+	* `webrun-http-port` in a follow-up release.
+	*/
+	async function sendHttpRequest(communicationPort, request) {
+		return await newHttpClientStub(async (req) => {
+			return await httpFromIterator(sendStream(communicationPort, httpToIterator(req)));
+		})(request);
+	}
+	//#endregion
+	//#region ../../node_modules/.pnpm/idb-keyval@6.3.0/node_modules/idb-keyval/dist/index.js
+	function promisifyRequest(request) {
+		return new Promise((resolve, reject) => {
+			request.oncomplete = request.onsuccess = () => resolve(request.result);
+			request.onabort = request.onerror = () => reject(request.error);
+		});
+	}
+	function createStore(dbName, storeName) {
+		let dbp;
+		const getDB = () => {
+			if (dbp) return dbp;
+			const request = indexedDB.open(dbName);
+			request.onupgradeneeded = () => request.result.createObjectStore(storeName);
+			dbp = promisifyRequest(request);
+			dbp.then((db) => {
+				db.onclose = () => dbp = void 0;
+			}, () => {
+				dbp = void 0;
+			});
+			return dbp;
+		};
+		return (txMode, callback) => getDB().then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
+	}
+	let defaultGetStoreFunc;
+	function defaultGetStore() {
+		if (!defaultGetStoreFunc) defaultGetStoreFunc = createStore("keyval-store", "keyval");
+		return defaultGetStoreFunc;
+	}
+	/**
+	* Get a value by its key.
+	*
+	* @param key
+	* @param customStore Method to get a custom store. Use with caution (see the docs).
+	*/
+	function get(key, customStore = defaultGetStore()) {
+		return customStore("readonly", (store) => promisifyRequest(store.get(key)));
+	}
+	/**
+	* Set a value with a key.
+	*
+	* @param key
+	* @param value
+	* @param customStore Method to get a custom store. Use with caution (see the docs).
+	*/
+	function set(key, value, customStore = defaultGetStore()) {
+		return customStore("readwrite", (store) => {
+			store.put(value, key);
+			return promisifyRequest(store.transaction);
+		});
+	}
+	//#endregion
+	//#region src/core/data-calls.ts
+	function callChannel(target, callType, params, ...transfers) {
+		return new Promise((resolve, reject) => {
+			const channel = new MessageChannel();
+			channel.port1.onmessage = (ev) => {
+				const { result, error } = ev.data;
+				if (error) reject(deserializeError(error));
+				else resolve(result);
+			};
+			target.postMessage({
+				type: callType,
+				params
+			}, [channel.port2, ...transfers]);
+		});
+	}
+	function handleChannelCalls(target, callType, handler) {
+		const listener = async (event) => {
+			if (!event.data || event.data.type !== callType) return;
+			const [port, ...transfers] = event.ports ?? [];
+			const response = {};
+			try {
+				response.result = await handler(event, event.data.params, ...transfers);
+			} catch (error) {
+				response.error = serializeError(error);
+			}
+			port?.postMessage(response);
+		};
+		target.addEventListener("message", listener);
+		target.start?.();
+		return () => target.removeEventListener("message", listener);
+	}
+	//#endregion
+	//#region src/sw/sw-dispatcher.ts
+	/**
+	* ServiceWorker-side counterpart: maintains an index of connected clients keyed by
+	* clientId, persisted in IndexedDB so it can reclaim ports across SW restarts.
+	*/
+	var SwPortDispatcher = class {
+		self;
+		log;
+		handlersIndex = /* @__PURE__ */ new Map();
+		/**
+		* Set of keys that were registered at some point on this SW (sticky —
+		* survives client closures + SW wake-ups via IndexedDB). Lets the fetch
+		* handler distinguish "site URL whose owner is gone → 404" from
+		* "unknown URL under scope → pass through to the network".
+		*/
+		claimedKeys = /* @__PURE__ */ new Set();
+		_cleanup;
+		_activationPromise;
+		constructor({ self, log = () => {} }) {
+			this.self = self;
+			this.log = log;
+		}
+		get scope() {
+			return `${new URL("./", this.self.location.href)}`;
+		}
+		/**
+		* Look up the active channel for a key. Returns `undefined` when there
+		* is no registration (or the registering client has gone away — stale
+		* entries are pruned in place).
+		*/
+		async loadChannelInfo(key) {
+			await this._checkActivation();
+			for (const channelInfo of this.handlersIndex.values()) {
+				if (channelInfo.key !== key) continue;
+				const clientId = channelInfo.clientId;
+				if (!clientId) continue;
+				if (!await this.self.clients.get(clientId)) {
+					this.handlersIndex.delete(clientId);
+					continue;
+				}
+				return channelInfo;
+			}
+		}
+		/** Whether `key` has ever been registered on this SW. */
+		isClaimedKey(key) {
+			return this.claimedKeys.has(key);
+		}
+		start() {
+			this._cleanup = handleChannelCalls(this.self, "UPDATE_COMMUNICATION_PORT", async (event, channelInfo, port) => {
+				const clientId = event.source?.id;
+				this.log("[UPDATE_COMMUNICATION_PORT]", clientId, channelInfo);
+				await this._updateChannelInfo({
+					...channelInfo,
+					port,
+					clientId
+				});
+				return { ...channelInfo };
+			});
+			this.self.addEventListener("install", (event) => {
+				this.log("Skip waiting on install.", event);
+				this.self.skipWaiting();
+			});
+			this.self.addEventListener("activate", (event) => {
+				this.log("Claim control over all clients.", event);
+				event.waitUntil((async () => {
+					await this.self.clients.claim();
+					await this._checkActivation();
+				})());
+			});
+		}
+		async stop() {
+			if (this._cleanup) {
+				this._cleanup();
+				this._cleanup = void 0;
+			}
+		}
+		_checkActivation() {
+			if (!this._activationPromise) this._activationPromise = this._activate();
+			return this._activationPromise;
+		}
+		async _activate() {
+			this.log("[checkActivation]");
+			const clientsIndex = await this._loadClientIds();
+			for (const [clientId, client] of clientsIndex.entries()) {
+				const messageChannel = new MessageChannel();
+				const port = messageChannel.port1;
+				const channelInfo = await callChannel(client, "UPDATE_COMMUNICATION_PORT", {}, messageChannel.port2);
+				await this._updateChannelInfo({
+					...channelInfo,
+					port,
+					clientId
+				});
+			}
+		}
+		async _updateChannelInfo(channelInfo) {
+			this.log("[updateClientInfo]", channelInfo);
+			if (!channelInfo.clientId) return;
+			this.handlersIndex.set(channelInfo.clientId, channelInfo);
+			if (channelInfo.key && !this.claimedKeys.has(channelInfo.key)) {
+				this.claimedKeys.add(channelInfo.key);
+				await set("claimedKeys", [...this.claimedKeys].sort());
+			}
+			await this._updateClientIds([]);
+		}
+		async _loadClientIds() {
+			const storedKeys = await get("claimedKeys") ?? [];
+			for (const key of storedKeys) this.claimedKeys.add(key);
+			const stored = await get("clientIds") ?? [];
+			return await this._updateClientIds(new Set(stored));
+		}
+		async _updateClientIds(clientIds) {
+			const ids = new Set(clientIds);
+			for (const clientId of this.handlersIndex.keys()) ids.add(clientId);
+			const index = /* @__PURE__ */ new Map();
+			for (const clientId of ids) {
+				const client = await this.self.clients.get(clientId);
+				if (client) index.set(clientId, client);
+				else this.handlersIndex.delete(clientId);
+			}
+			await set("clientIds", [...index.keys()].sort());
+			return index;
+		}
+	};
+	//#endregion
+	//#region src/sw/http-sw-dispatcher.ts
+	var SwHttpDispatcher = class extends SwPortDispatcher {
+		start() {
+			super.start();
+			this.self.addEventListener("fetch", this._handleFetchEvent.bind(this));
+		}
+		_handleFetchEvent(event) {
+			event.respondWith((async () => {
+				const request = event.request;
+				try {
+					const requestUrl = request.url;
+					const rootUrl = this.scope;
+					if (requestUrl.indexOf(rootUrl) === 0) {
+						const key = requestUrl.substring(rootUrl.length).replace(/^\/?([^/]+).*$/, "$1");
+						const channelInfo = await this.loadChannelInfo(key);
+						if (channelInfo?.port) return await sendHttpRequest(channelInfo.port, request);
+						if (this.isClaimedKey(key)) return new Response(null, {
+							status: 404,
+							statusText: "Not Found (no active handler)"
+						});
+					}
+					return await fetch(request);
+				} catch (error) {
+					console.error(error);
+					return new Response(null, {
+						status: 500,
+						statusText: "Error 500: Internal error"
+					});
+				}
+			})());
+		}
+	};
+	function startHttpDispatcher(options) {
+		const dispatcher = new SwHttpDispatcher(options);
+		dispatcher.start();
+		return () => {
+			dispatcher.stop();
+		};
+	}
+	//#endregion
+	//#region src/sw-worker.ts
+	startHttpDispatcher({
+		self,
+		log: console.log
+	});
+	//#endregion
+})();