@statewalker/webrun-http-browser 0.3.3 → 0.3.4

package/dist/sw.js

@@ -0,0 +1,1076 @@
+//#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;
+}
+/**
+* Drain a body iterable into one contiguous buffer. Only the fallbacks need it.
+* Allocates its own buffer rather than reusing `bytes.ts`'s `concatChunks`,
+* which passes a single chunk straight through: that chunk is a view onto the
+* decoder's own read buffer, and the result here is handed to `new Request` and
+* outlives the decode. The allocation is also what makes it a
+* `Uint8Array<ArrayBuffer>`, which `BodyInit` accepts and the looser
+* `Uint8Array<ArrayBufferLike>` does not.
+*/
+async function collectBytes(source) {
+	const parts = [];
+	let total = 0;
+	for await (const chunk of source) {
+		if (chunk.byteLength === 0) continue;
+		parts.push(chunk);
+		total += chunk.byteLength;
+	}
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		out.set(part, offset);
+		offset += part.byteLength;
+	}
+	return out;
+}
+//#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);
+	};
+}
+/**
+* Returns a server-side transport handler. It deserializes the incoming
+* request envelope, delegates to `handler`, and serializes the response.
+*/
+function newHttpServerStub(handler) {
+	return async (envelopeOrPromise) => {
+		const { options, content } = await envelopeOrPromise;
+		const { url, method, headers = [], ...rest } = options;
+		const { mode: _mode, ...forwardable } = rest;
+		const requestHeaders = new Headers();
+		for (const [key, value] of headers) requestHeaders.append(key, value);
+		const hasBody = method !== "GET" && method !== "HEAD" && method !== "OPTIONS";
+		const requestInit = {
+			...forwardable,
+			method,
+			headers: requestHeaders
+		};
+		if (!hasBody) await discard(content);
+		else if (supportsRequestStreams()) {
+			requestInit.body = toReadableStream(content[Symbol.asyncIterator]());
+			requestInit.duplex = "half";
+		} else requestInit.body = await collectBytes(content);
+		const response = await handler(new Request(url, requestInit));
+		return {
+			options: {
+				status: response.status,
+				statusText: response.statusText,
+				headers: Object.fromEntries([...response.headers])
+			},
+			content: response.body ? fromReadableStream(response.body) : (async function* () {})()
+		};
+	};
+}
+//#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 handleStreams(communicationPort, handler) {
+	const listener = async (event) => {
+		const { type, params } = event.data ?? {};
+		if (type !== "START_CALL") return;
+		const port = event.ports[0];
+		const channel = newStreamChannel(port);
+		try {
+			await channel.start();
+			const response = await handler(channel.recieveAll(), params ?? {});
+			await channel.sendAll(response);
+		} finally {
+			await channel.close();
+		}
+	};
+	communicationPort.addEventListener("message", listener);
+	communicationPort.start?.();
+	return () => communicationPort.removeEventListener("message", listener);
+}
+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`. Once a `MessagePort` is established between
+* page and worker, `httpServe(port, handler)` provides equivalent semantics
+* with `callBidi` multiplexing, full-duplex streaming, and `AbortSignal`.
+* This helper remains for existing ServiceWorker setups that still consume the
+* `MessageTarget` surface; it will be reimplemented on top of
+* `webrun-http-port` in a follow-up release.
+*/
+function handleHttpRequests(communicationPort, handler) {
+	const serverStub = newHttpServerStub(handler);
+	return handleStreams(communicationPort, async (it) => {
+		const envelope = await httpFromIterator(it);
+		return httpToIterator(await serverStub(envelope));
+	});
+}
+/**
+* @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/core/registry.ts
+function newRegistry(onError = console.error) {
+	let counter = 0;
+	const registrations = {};
+	const register = (action) => {
+		const id = counter++;
+		const fn = Object.assign((skip) => {
+			try {
+				delete registrations[id];
+				return skip ? void 0 : action();
+			} catch (error) {
+				onError(error);
+			}
+		}, { action });
+		registrations[id] = fn;
+		return fn;
+	};
+	const unregister = (action) => {
+		for (const r of Object.values(registrations)) if (r.action === action) r(true);
+	};
+	const clear = () => {
+		for (const r of Object.values(registrations)) r();
+	};
+	return Object.assign([
+		register,
+		clear,
+		unregister
+	], {
+		register,
+		clear,
+		unregister
+	});
+}
+//#endregion
+//#region src/sw/sw-dispatcher.ts
+/**
+* Page-side counterpart: registers a ServiceWorker and sets up a
+* MessageChannel with it, re-establishing the connection after SW wake-ups.
+*/
+var SwPortHandler = class {
+	options;
+	_serviceWorkerUrl;
+	_serviceWorker;
+	_registrationPromise;
+	_cleanupRegistrations;
+	constructor(options) {
+		this.options = options;
+		if (!this.key) throw new Error("Key is not defined.");
+		if (!this.scope) throw new Error("Scope is not defined");
+	}
+	get key() {
+		return this.options.key;
+	}
+	get scope() {
+		return this.options.scope ?? new URL("./", this.serviceWorkerUrl).pathname;
+	}
+	get rootUrl() {
+		return new URL(this.scope, import.meta.url);
+	}
+	get serviceWorkerUrl() {
+		if (!this._serviceWorkerUrl) {
+			const url = this.options.serviceWorkerUrl ? new URL(this.options.serviceWorkerUrl) : new URL("./index-sw.js", this.rootUrl);
+			this._serviceWorkerUrl = `${url}`;
+		}
+		return this._serviceWorkerUrl;
+	}
+	async _newCommunicationChannel() {
+		const messageChannel = new MessageChannel();
+		return [messageChannel.port1, messageChannel.port2];
+	}
+	async _setCommunicationPort(port) {
+		await this.options.bindPort(port);
+	}
+	async _updateCommunicationChannel() {
+		if (!this._serviceWorker) return;
+		const [port1, port2] = await this._newCommunicationChannel();
+		await this._setCommunicationPort(port1);
+		await callChannel(this._serviceWorker, "UPDATE_COMMUNICATION_PORT", this._getRegistrationInfo(), port2);
+	}
+	_getRegistrationInfo() {
+		return { key: this.key };
+	}
+	async start() {
+		if (!this._registrationPromise) this._registrationPromise = (async () => {
+			const [register, cleanup] = newRegistry();
+			this._cleanupRegistrations = cleanup;
+			register(() => {
+				this._cleanupRegistrations = void 0;
+			});
+			const registration = await navigator.serviceWorker.register(this.serviceWorkerUrl, { scope: this.scope });
+			register(() => registration.unregister());
+			register(handleChannelCalls(navigator.serviceWorker, "UPDATE_COMMUNICATION_PORT", async (_event, _params, port) => {
+				await this._setCommunicationPort(port);
+				return this._getRegistrationInfo();
+			}));
+			this._serviceWorker = await getServiceWorkerController();
+			await awaitServiceWorkerActivation(this._serviceWorker);
+			await this._updateCommunicationChannel();
+		})();
+		return this._registrationPromise;
+	}
+	async stop() {
+		this._cleanupRegistrations?.();
+		const registrations = await navigator.serviceWorker.getRegistrations();
+		for (const registration of registrations) try {
+			await registration.unregister();
+		} catch (error) {
+			console.log("Service Worker registration failed: ", error);
+		}
+	}
+};
+function getServiceWorkerController() {
+	return new Promise((resolve) => {
+		const container = navigator.serviceWorker;
+		if (container.controller) {
+			resolve(container.controller);
+			return;
+		}
+		const onChange = () => {
+			if (!container.controller) return;
+			resolve(container.controller);
+			container.removeEventListener("controllerchange", onChange);
+		};
+		container.addEventListener("controllerchange", onChange);
+	});
+}
+function awaitServiceWorkerActivation(worker) {
+	return new Promise((resolve) => {
+		if (worker.state === "activated") {
+			resolve();
+			return;
+		}
+		const onStateChange = () => {
+			if (worker.state !== "activated") return;
+			worker.removeEventListener("statechange", onStateChange);
+			resolve();
+		};
+		worker.addEventListener("statechange", onStateChange);
+	});
+}
+/**
+* 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 SwHttpAdapter = class extends SwPortHandler {
+	_handlers = /* @__PURE__ */ new Map();
+	_cleanupRequestChannel;
+	constructor(options) {
+		super({
+			bindPort: () => {},
+			...options
+		});
+	}
+	async _setCommunicationPort(port) {
+		this._cleanupRequestChannel?.();
+		this._cleanupRequestChannel = handleHttpRequests(port, this._handleHttpRequest.bind(this));
+	}
+	async _handleHttpRequest(request) {
+		const requestUrl = request.url;
+		for (const [urlPrefix, handler] of this._handlers) if (requestUrl.indexOf(urlPrefix) === 0) return handler(request);
+		return new Response(null, {
+			status: 404,
+			statusText: "Error 404: Not found"
+		});
+	}
+	/**
+	* Registers an HTTP handler on a prefix. Returns the resulting base URL and a
+	* disposer.
+	*/
+	async register(prefix, handler) {
+		const cleanPrefix = `./${(prefix ?? "").replace(/^[./]+/, "")}`;
+		const baseUrl = `${new URL(cleanPrefix, this.rootUrl)}`;
+		this._handlers.set(baseUrl, handler);
+		const handlers = this._handlers;
+		return {
+			baseUrl,
+			prefix: cleanPrefix,
+			async remove() {
+				handlers.delete(baseUrl);
+			}
+		};
+	}
+};
+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
+export { SwHttpAdapter, SwHttpDispatcher, SwPortDispatcher, SwPortHandler, startHttpDispatcher };