@statewalker/webrun-http-browser 0.3.3 → 0.3.4

package/dist/relay-sw.js

@@ -0,0 +1,878 @@
+(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 ../webrun-http-streams/src/http-error.ts
+	var HttpError = class HttpError extends Error {
+		status;
+		statusText;
+		constructor(options = {}) {
+			super(options.message ?? options.statusText ?? "HTTP Error");
+			this.status = options.status;
+			this.statusText = options.statusText;
+		}
+		getResponseOptions(options = {}) {
+			return {
+				...this.toJson(),
+				...options
+			};
+		}
+		toJson() {
+			return {
+				status: this.status,
+				statusText: this.statusText,
+				message: this.message
+			};
+		}
+		static fromError(error) {
+			if (error instanceof HttpError) return error;
+			const message = error instanceof Error ? error.message : String(error);
+			return new HttpError({
+				status: 500,
+				statusText: "Bad Request",
+				message
+			});
+		}
+		static errorResourceNotFound(options = {}) {
+			return new HttpError({
+				status: 404,
+				statusText: "Error 404: Resource not found",
+				...options
+			});
+		}
+		static errorForbidden(options = {}) {
+			return new HttpError({
+				status: 403,
+				statusText: "Error 403: Forbidden",
+				...options
+			});
+		}
+		static errorResourceGone(options = {}) {
+			return new HttpError({
+				status: 410,
+				statusText: "Error 410: Resource Gone",
+				...options
+			});
+		}
+		static errorInternalError(options = {}) {
+			return new HttpError({
+				...options,
+				status: 500,
+				statusText: "Error 500: Internal error"
+			});
+		}
+	};
+	//#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/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 src/relay/split-service-url.ts
+	/**
+	* Splits a URL of the form `<base>/<separator><key>/<path>` into parts.
+	* Example: `https://host/~FS/a/b` → `{ baseUrl: "https://host/~FS/", key: "FS", path: "a/b" }`.
+	*/
+	function splitServiceUrl(url, separator = "~") {
+		const str = `${url}`;
+		const idx = str.indexOf(separator);
+		let baseUrl = "";
+		let key = "";
+		let path = "";
+		if (idx >= 0) {
+			baseUrl = str.substring(0, idx + separator.length);
+			str.substring(idx + separator.length).replace(/^([^/]+)/, (match, $1) => {
+				baseUrl += match;
+				if (baseUrl.length < str.length) baseUrl += "/";
+				key = $1;
+				path = str.substring(baseUrl.length);
+				return "";
+			});
+		}
+		return {
+			url: str,
+			key,
+			baseUrl,
+			path
+		};
+	}
+	//#endregion
+	//#region src/relay/index-sw.ts
+	/**
+	* Boots the relay ServiceWorker: routes fetches shaped `<origin>/~<key>/…` to
+	* the client that registered `key`, and exposes REGISTER/UNREGISTER/CONNECT
+	* channel calls used by the page-side relay client.
+	*/
+	function startRelayServiceWorker(self) {
+		const [register, clear] = newRegistry();
+		if (typeof self.skipWaiting === "function") self.addEventListener("install", (e) => {
+			e.waitUntil(self.skipWaiting());
+		});
+		if (self.clients && typeof self.clients.claim === "function") self.addEventListener("activate", (e) => {
+			e.waitUntil(self.clients.claim());
+		});
+		const clientsRegistry = newClientsRegistry({ self });
+		register(handleChannelCalls(self, "REGISTER", async (event, data) => {
+			const source = event.source;
+			if (!source) return false;
+			const { key } = data;
+			return await clientsRegistry.addClient(key, source);
+		}));
+		register(handleChannelCalls(self, "UNREGISTER", async (_event, data) => {
+			const { key } = data;
+			return await clientsRegistry.removeClient(key);
+		}));
+		register(handleChannelCalls(self, "CONNECT", async (_event, data, port) => {
+			const { key } = data;
+			const client = await clientsRegistry.getClient(key);
+			if (!client) throw new Error(`Target client was not found. Target key: "${key}".`);
+			return await callChannel(client, "CONNECT", data, port);
+		}));
+		const fetchListener = (event) => {
+			const request = event.request;
+			const params = splitServiceUrl(request.url);
+			const { key } = params;
+			if (!key) return;
+			event.respondWith((async () => {
+				try {
+					const channel = new MessageChannel();
+					const client = await clientsRegistry.getClient(key);
+					if (!client) throw HttpError.errorResourceGone(params);
+					if (!await callChannel(client, "CONNECT", {
+						type: "http",
+						key
+					}, channel.port2)) throw HttpError.errorForbidden(params);
+					return await sendHttpRequest(channel.port1, request);
+				} catch (error) {
+					const httpError = HttpError.fromError(error);
+					const options = httpError.getResponseOptions(params);
+					return new Response(JSON.stringify(options), {
+						status: httpError.status ?? 500,
+						statusText: httpError.statusText ?? "Internal Error",
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+			})());
+		};
+		self.addEventListener("fetch", fetchListener);
+		register(() => self.removeEventListener("fetch", fetchListener));
+		return clear;
+	}
+	function newClientsRegistry({ self, key = "clientsIds" }) {
+		let _index;
+		async function loadClientsIndex() {
+			if (!_index) {
+				const entries = await get(key) ?? [];
+				_index = Object.fromEntries(entries);
+			}
+			return _index;
+		}
+		async function storeClientsIndex() {
+			const index = await loadClientsIndex();
+			await set(key, Object.entries(index));
+			return index;
+		}
+		async function addClient(clientKey, client) {
+			const index = await loadClientsIndex();
+			const clientId = client.id;
+			if (index[clientKey] === clientId) return false;
+			index[clientKey] = clientId;
+			await storeClientsIndex();
+			return true;
+		}
+		async function removeClient(clientKey) {
+			const index = await loadClientsIndex();
+			if (!(clientKey in index)) return false;
+			delete index[clientKey];
+			await storeClientsIndex();
+			return true;
+		}
+		async function getClient(clientKey) {
+			const index = await loadClientsIndex();
+			const clientId = index[clientKey];
+			if (!clientId) return void 0;
+			const client = await self.clients.get(clientId);
+			if (!client) {
+				delete index[clientKey];
+				await storeClientsIndex();
+			}
+			return client ?? void 0;
+		}
+		return {
+			getClient,
+			addClient,
+			removeClient
+		};
+	}
+	//#endregion
+	//#region src/relay-sw.ts
+	startRelayServiceWorker(self);
+	//#endregion
+})();