@statewalker/webrun-http-browser 0.6.4 → 0.7.0

package/dist/index.js

@@ -884,7 +884,56 @@ function toChunks(size = DEFAULT_CHUNK_SIZE) {
 	};
 }
 //#endregion
+//#region src/core/deadline.ts
+/**
+* Settles like `promise` if it settles before `deadline` (a `Date.now()`
+* value). Otherwise calls `onTimeout`: an `Error` it returns rejects, any
+* other value resolves. Internal; not re-exported.
+*/
+function withDeadline(deadline, promise, onTimeout) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			const outcome = onTimeout();
+			if (outcome instanceof Error) reject(outcome);
+			else resolve(outcome);
+		}, Math.max(0, deadline - Date.now()));
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+}
+//#endregion
 //#region src/core/data-calls.ts
+const TRANSFER = Symbol.for("webrun-http-browser:transfer");
+/**
+* A channel call's result that carries transferables, a `MessagePort` say:
+* return `withTransfer({ port }, [port])` from a `handleChannelCalls` handler
+* and `callChannel` resolves with `{ port }`.
+*/
+function withTransfer(value, transfer) {
+	return {
+		[TRANSFER]: true,
+		value,
+		transfer
+	};
+}
+function isTransferResult(value) {
+	return typeof value === "object" && value !== null && TRANSFER in value;
+}
+/** Splits a handler's result into the value to post and its transfer list. */
+function unwrapTransfer(result) {
+	return isTransferResult(result) ? {
+		value: result.value,
+		transfer: result.transfer
+	} : {
+		value: result,
+		transfer: []
+	};
+}
 function callChannel(target, callType, params, ...transfers) {
 	return new Promise((resolve, reject) => {
 		const channel = new MessageChannel();
@@ -904,17 +953,27 @@ function handleChannelCalls(target, callType, handler) {
 		if (!event.data || event.data.type !== callType) return;
 		const [port, ...transfers] = event.ports ?? [];
 		const response = {};
+		let transfer = [];
 		try {
-			response.result = await handler(event, event.data.params, ...transfers);
+			const result = await handler(event, event.data.params, ...transfers);
+			({value: response.result, transfer} = unwrapTransfer(result));
 		} catch (error) {
 			response.error = serializeError(error);
 		}
-		port?.postMessage(response);
+		port?.postMessage(response, transfer);
 	};
 	target.addEventListener("message", listener);
 	target.start?.();
 	return () => target.removeEventListener("message", listener);
 }
+/**
+* `callChannel`, failing after `ms` instead of waiting for ever: a peer that
+* died (a ServiceWorker stopped mid-call) or that does not know `callType` (an
+* older version) never answers.
+*/
+function callChannelWithin(ms, target, callType, params, ...transfers) {
+	return withDeadline(Date.now() + ms, callChannel(target, callType, params, ...transfers), () => /* @__PURE__ */ new Error(`No answer to ${callType} within ${ms} ms`));
+}
 //#endregion
 //#region src/core/data-channels.ts
 const MESSAGE_TYPE_REQUEST = "REQUEST";
@@ -1125,29 +1184,6 @@ function newRegistry(onError = console.error) {
 	});
 }
 //#endregion
-//#region src/core/deadline.ts
-/**
-* Settles like `promise` if it settles before `deadline` (a `Date.now()`
-* value). Otherwise calls `onTimeout`: an `Error` it returns rejects, any
-* other value resolves. Internal; not re-exported.
-*/
-function withDeadline(deadline, promise, onTimeout) {
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			const outcome = onTimeout();
-			if (outcome instanceof Error) reject(outcome);
-			else resolve(outcome);
-		}, Math.max(0, deadline - Date.now()));
-		promise.then((value) => {
-			clearTimeout(timer);
-			resolve(value);
-		}, (error) => {
-			clearTimeout(timer);
-			reject(error);
-		});
-	});
-}
-//#endregion
 //#region src/core/service-worker-control.ts
 /**
 * How long, by default, the page waits for its ServiceWorker to activate and
@@ -2147,11 +2183,41 @@ async function throwIfPeerError(result, output) {
 async function httpFetch(call, env, body, options = {}) {
 	const codec = options.codec ?? defaultCodec;
 	const output = call(codec.encodeRequest(env, body));
-	const result = await codec.decodeResponse(output, { method: env.method });
+	const decoded = await codec.decodeResponse(output, { method: env.method });
+	const release = async () => {
+		try {
+			await output.return?.(void 0);
+		} catch {}
+	};
+	const result = {
+		envelope: decoded.envelope,
+		body: releasingOnExit(decoded.body, release),
+		release
+	};
 	await throwIfPeerError(result, output);
 	return result;
 }
 /**
+* `body`, but leaving it before its end releases the call.
+*
+* The body the codec hands back is a generator of its own over a `ByteReader`,
+* and `.return()` on it never reaches the call's `output` (see
+* `throwIfPeerError` for why the codec must not do that itself). So a caller
+* that stopped reading — an aborted `fetch`, a cancelled response stream —
+* left the peer's producer parked forever, holding its handler open. Safe here
+* for the same reason it is safe in `throwIfPeerError`: `output` is this
+* call's own response-only generator, and the request was fully sent.
+*/
+async function* releasingOnExit(body, release) {
+	let completed = false;
+	try {
+		yield* body;
+		completed = true;
+	} finally {
+		if (!completed) await release();
+	}
+}
+/**
 * Wrap an HTTP handler as a `Duplex` so it can be registered with any
 * `webrun-streams-*` adapter's `serve`.
 */
@@ -2174,7 +2240,15 @@ function httpServe(handler, options = {}) {
 			yield* encodeErrorResponse(replyCodec, error, decoded.envelope.method);
 			return;
 		}
-		yield* replyCodec.encodeResponse(result.envelope, result.body, { method: decoded.envelope.method });
+		let completed = false;
+		try {
+			yield* replyCodec.encodeResponse(result.envelope, result.body, { method: decoded.envelope.method });
+			completed = true;
+		} finally {
+			if (!completed) try {
+				await result.release?.();
+			} catch {}
+		}
 	};
 }
 /**
@@ -2414,7 +2488,7 @@ function asyncIterableToReadable(iter) {
 * abort terminates the underlying call.
 */
 async function fetchOverDuplex(call, request, options = {}) {
-	if (request.signal?.aborted) throw abortReason(request.signal);
+	if (request.signal?.aborted) throw abortReason$1(request.signal);
 	const env = {
 		url: request.url,
 		method: request.method,
@@ -2426,14 +2500,14 @@ async function fetchOverDuplex(call, request, options = {}) {
 		const buffered = new Uint8Array(await request.arrayBuffer());
 		if (buffered.byteLength > 0) body = [buffered];
 	}
-	const { envelope, body: respBody } = await httpFetch(call, env, body, options);
+	const { envelope, body: respBody, release } = await httpFetch(call, env, body, options);
 	const responseInit = {
 		status: envelope.status,
 		statusText: envelope.statusText,
 		headers: forwardableHeaders(envelope.headers)
 	};
 	if (request.method === "HEAD" || request.method === "OPTIONS" || NULL_BODY_STATUSES.has(envelope.status)) {
-		await respBody.return?.();
+		await release?.();
 		return new Response(null, responseInit);
 	}
 	return new Response(asyncIterableToReadable(withAbort(respBody, request.signal)), responseInit);
@@ -2469,7 +2543,8 @@ function serveFetchOverDuplex(handler, options = {}) {
 		}
 		return {
 			envelope: respEnv,
-			body: response.body ? readableToAsyncIterable(response.body) : void 0
+			body: response.body ? readableToAsyncIterable(response.body) : void 0,
+			release: () => response.body?.cancel()
 		};
 	}, options);
 }
@@ -2479,11 +2554,11 @@ async function* withAbort(iter, signal) {
 		return;
 	}
 	for await (const chunk of iter) {
-		if (signal.aborted) throw abortReason(signal);
+		if (signal.aborted) throw abortReason$1(signal);
 		yield chunk;
 	}
 }
-function abortReason(signal) {
+function abortReason$1(signal) {
 	const reason = signal.reason;
 	if (reason instanceof Error) return reason;
 	const err = new Error(reason === void 0 ? "Aborted" : String(reason));
@@ -2653,150 +2728,2088 @@ async function sendHttpRequest(communicationPort, request) {
 	})(request);
 }
 //#endregion
-//#region src/relay/split-service-url.ts
+//#region ../webrun-rpc/dist/index.js
+const closeSignals = /* @__PURE__ */ new WeakMap();
 /**
-* 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" }`.
+* Internal: register a port's close signal. Called once by `bindBytesToPort`.
+*
+* @internal
 */
-function splitServiceUrl(url, separator = "~") {
-	const str = `${url}`;
-	const empty = {
-		url: str,
-		key: "",
-		baseUrl: "",
-		path: ""
+function setPortCloseSignal(port, signal) {
+	closeSignals.set(port, signal);
+}
+/**
+* Return the AbortSignal that fires when `port`'s transport closes, or
+* `undefined` if `port` is not transport-backed (e.g., a raw
+* `MessageChannel().port1`).
+*/
+function getPortCloseSignal(port) {
+	return closeSignals.get(port);
+}
+/**
+* Pass as `timeout` to install no deadline at all. Used by the stream tier,
+* where the deadline belongs to the stream rather than to one chunk (spec D8):
+* a slow consumer is throttled, never failed.
+*/
+const NO_TIMEOUT = Number.POSITIVE_INFINITY;
+/**
+* Asynchronous request/response over any `MessageTarget`.
+*
+* Sends `params` to the peer listening with `listenPort`, waits up to
+* `timeout` ms for a matching reply, and either resolves with the result or
+* rejects with the deserialised error.
+*/
+function callPort(port, params, { timeout = 1e3, channelName = "", log = () => {}, newCallId = () => `call-${Date.now()}-${String(Math.random()).substring(2)}`, signal } = {}) {
+	const callId = newCallId();
+	log("[callPort]", {
+		channelName,
+		callId,
+		params
+	});
+	const combinedSignal = combineSignals(signal, getPortCloseSignal(port));
+	let timerId;
+	let onMessage;
+	let onAbort;
+	const promise = new Promise((resolve, reject) => {
+		if (combinedSignal?.aborted) {
+			reject(abortReason(combinedSignal));
+			return;
+		}
+		if (Number.isFinite(timeout) && timeout > 0) timerId = setTimeout(() => reject(/* @__PURE__ */ new Error(`Call timeout. CallId: "${callId}".`)), timeout);
+		onMessage = (event) => {
+			const data = event.data;
+			if (!data) return;
+			if (data.channelName !== channelName) return;
+			if (data.callId !== callId) return;
+			if (data.type === "response:error") reject(deserializeError(data.error));
+			else if (data.type === "response:result") resolve(data.result);
+		};
+		port.addEventListener("message", onMessage);
+		if (combinedSignal) {
+			onAbort = () => reject(abortReason(combinedSignal));
+			combinedSignal.addEventListener("abort", onAbort, { once: true });
+		}
+	});
+	promise.catch(() => {}).finally(() => {
+		if (timerId !== void 0) clearTimeout(timerId);
+		if (onMessage) port.removeEventListener("message", onMessage);
+		if (onAbort && combinedSignal) combinedSignal.removeEventListener("abort", onAbort);
+	});
+	port.postMessage({
+		type: "request",
+		channelName,
+		callId,
+		params
+	});
+	return promise;
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	const err = new Error(reason === void 0 ? "Aborted" : String(reason));
+	err.name = "AbortError";
+	return err;
+}
+function combineSignals(...signals) {
+	const live = signals.filter((s) => s !== void 0);
+	if (live.length === 0) return void 0;
+	if (live.length === 1) return live[0];
+	return AbortSignal.any(live);
+}
+/**
+* Installs `handler` as the server side of a `callPort` / `listenPort`
+* request/response pair on `port`.
+*
+* Returns a cleanup function that removes the listener.
+*/
+function listenPort(port, handler, { channelName = "", log = () => {} } = {}) {
+	const onMessage = async (event) => {
+		const data = event.data;
+		if (!data || data.channelName !== channelName || data.type !== "request") return;
+		const { callId, params } = data;
+		log("[listenPort]", {
+			channelName,
+			callId,
+			params
+		});
+		let result;
+		let error;
+		let type;
+		try {
+			result = await handler(params);
+			type = "response:result";
+		} catch (e) {
+			error = serializeError(e);
+			type = "response:error";
+		}
+		port.postMessage({
+			callId,
+			channelName,
+			type,
+			result,
+			error
+		});
 	};
-	const hashIdx = str.indexOf("#");
-	const queryIdx = str.indexOf("?");
-	let strippedEnd = str.length;
-	if (hashIdx >= 0) strippedEnd = Math.min(strippedEnd, hashIdx);
-	if (queryIdx >= 0) strippedEnd = Math.min(strippedEnd, queryIdx);
-	const stripped = str.slice(0, strippedEnd);
-	let prefixEnd = 0;
-	const schemeMatch = stripped.match(/^[a-zA-Z][a-zA-Z0-9+\-.]*:\/\//);
-	if (schemeMatch) {
-		prefixEnd = schemeMatch[0].length;
-		const slashIdx = stripped.indexOf("/", prefixEnd);
-		if (slashIdx >= 0) prefixEnd = slashIdx;
-		else return empty;
-	} else if (stripped.startsWith("//")) {
-		prefixEnd = 2;
-		const slashIdx = stripped.indexOf("/", prefixEnd);
-		if (slashIdx >= 0) prefixEnd = slashIdx;
-		else return empty;
+	port.addEventListener("message", onMessage);
+	return () => port.removeEventListener("message", onMessage);
+}
+/**
+* Wraps an async iterable so that an `AbortSignal` firing causes the wrapper
+* to return cleanly, forwarding `return()` to the underlying iterator so the
+* producer (e.g., a user-supplied generator) sees its own `finally` blocks
+* run immediately rather than waiting for the next yield.
+*/
+async function* throughAbort(input, signal) {
+	const iter = input[Symbol.asyncIterator] ? input[Symbol.asyncIterator]() : input[Symbol.iterator]();
+	const onAbort = () => {
+		iter.return?.(void 0);
+	};
+	if (signal.aborted) {
+		iter.return?.(void 0);
+		return;
 	}
-	const prefix = stripped.slice(0, prefixEnd);
-	const pathPart = stripped.slice(prefixEnd);
-	let keyStart;
-	let rooted = false;
-	if (prefix === "") {
-		if (pathPart.startsWith(`/${separator}`)) {
-			rooted = true;
-			keyStart = separator.length + 1;
-		} else if (pathPart.startsWith(separator)) keyStart = separator.length;
-		else return empty;
-	} else {
-		if (!pathPart.startsWith(`/${separator}`)) return empty;
-		keyStart = separator.length + 1;
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (true) {
+			const r = await iter.next();
+			if (r.done) return;
+			if (signal.aborted) return;
+			yield r.value;
+		}
+	} finally {
+		signal.removeEventListener("abort", onAbort);
 	}
-	const rest = pathPart.slice(keyStart);
-	const slash = rest.indexOf("/");
-	const key = slash < 0 ? rest : rest.slice(0, slash);
-	if (key === "") return empty;
-	return {
-		url: str,
-		key,
-		baseUrl: `${prefix === "" ? rooted ? "/" : "" : `${prefix}/`}${separator}${key}${slash < 0 ? "" : "/"}`,
-		path: slash < 0 ? "" : rest.slice(slash + 1)
-	};
 }
-//#endregion
-//#region src/relay/index.ts
 /**
-* The URL of this module, kept in a variable on purpose. Bundlers (Vite
-* among them) rewrite every literal `new URL("<path>", import.meta.url)` into
-* an emitted asset at build time, before tree-shaking — so the defaults below
-* made every Vite consumer of this entry emit a dead copy of the package's
-* own `dist/index.js` (`"../"` resolves to the package, hence to its `main`).
-* Resolving against a variable is the same URL at run time and invisible to
-* that transform.
+* The `type` of the out-of-band notice a side posts when it abandons a stream.
+*
+* Layer 1's `close` is not observable to layer 2 — a closed virtual port drops
+* its listeners silently and is indistinguishable from a working port nobody
+* is answering — so the peer would otherwise wait forever. Exported because
+* tests and adapters assert on it.
 */
-const moduleUrl = import.meta.url;
+const STREAM_ABORT = "webrun-rpc:stream-abort";
+/** Caller's input travels on this channel; the handler listens on it. */
+const CHANNEL_IN = "in";
+/** The handler's output travels on this channel; the caller listens on it. */
+const CHANNEL_OUT = "out";
 /**
-* Returns a MessagePort that transparently bridges messages to/from the
-* page's ServiceWorker: the one controlling the page, or — when the page is
-* not controlled (a hard reload, or a page Firefox left uncontrolled) — the
-* active worker of `registration`, which answers messages all the same.
+* One port in, one `Duplex` out (spec D9).
+*
+* The returned `Duplex` runs a single stream on `port`: the caller's `input`
+* is sent chunk by chunk with `callPort`, and the handler's output arrives the
+* same way on the other channel. Within each direction the next chunk is never
+* sent until the previous one has been delivered *and* pulled past by the
+* consumer (spec D11) — the reply to a chunk call *is* the confirmation, and
+* `listenPort` withholds it until then.
+*
+* A stream port carries exactly one invocation. To make several calls, open
+* several ports: `mux.openPort({ kind: "stream" })` per call.
 */
-function newServiceWorkerPort(registration) {
-	const channel = new MessageChannel();
-	channel.port1.onmessage = (event) => {
-		(navigator.serviceWorker.controller ?? registration?.active)?.postMessage(event.data, [...event.ports]);
-	};
-	navigator.serviceWorker.addEventListener("message", (event) => {
-		channel.port1.postMessage(event.data, [...event.ports]);
-	});
-	return channel.port2;
+function duplexOverPort(port, options = {}) {
+	return (input) => runCallerSide(port, input, options);
 }
 /**
-* Registers a ServiceWorker and resolves with it once it is activated: the
-* worker controlling the page, or the registration's active worker when the
-* page is not controlled. Messaging works either way, which is all the relay
-* needs; nothing here waits for control, because an uncontrolled page (hard
-* reload; Firefox) may never get it. Rejects with a
-* `ServiceWorkerControlError` if activation takes longer than `timeout`.
+* Installs `handler` as the serving side of one stream on `port`. Returns an
+* idempotent teardown that abandons the stream and notifies the peer.
 */
-async function initServiceWorker(options) {
-	return (await registerServiceWorker(options)).worker;
+function serveDuplexOverPort(port, handler, options = {}) {
+	const controller = new AbortController();
+	const notice = installAbortNotice(port, controller);
+	abortOnPortClose(port, controller);
+	const clock = installStreamTimeout(controller, options.timeout);
+	const inbound = receiveChunks(port, CHANNEL_IN, controller, clock.touch);
+	let output;
+	try {
+		output = handler(inbound.stream);
+	} catch (err) {
+		const pump = sendChunks(port, CHANNEL_OUT, failing(err), options, controller.signal, clock.touch);
+		pump.catch(() => {});
+		disarmClockWhenBothSidesSettle(clock, pump, inbound.ended);
+		return teardownOnce(controller, notice, clock, inbound, void 0);
+	}
+	const pump = sendChunks(port, CHANNEL_OUT, output, options, controller.signal, clock.touch);
+	pump.catch(() => {});
+	disarmClockWhenBothSidesSettle(clock, pump, inbound.ended);
+	return teardownOnce(controller, notice, clock, inbound, output);
 }
-async function registerServiceWorker({ swUrl, scopeUrl, type, timeout = DEFAULT_SERVICE_WORKER_TIMEOUT }) {
-	const registration = await navigator.serviceWorker.register(swUrl, {
-		type,
-		scope: scopeUrl
+/**
+* A stream that completes normally has nobody left to call the returned
+* teardown — the caller only knows the stream ended, not that it must also
+* dispose the serve-side handle. Without this, the last `touch()`'s timer
+* stays armed for up to `timeout` ms after real completion, doing nothing
+* but holding the event loop open.
+*
+* Only disarms once BOTH `pump` (our output) and `inboundEnded` (the peer's
+* declared end of input, or an abort) have settled. Disarming on `pump`
+* alone is not safe: under half-close the handler can finish producing
+* output while the caller is still sending input, and a clock stopped then
+* would leave that still-open half with no deadline at all — worse than the
+* leak this fixes.
+*/
+function disarmClockWhenBothSidesSettle(clock, pump, inboundEnded) {
+	Promise.allSettled([pump, inboundEnded]).then(() => {
+		clock.stop();
 	});
-	const active = await awaitActiveServiceWorker(registration, { timeout });
-	return {
-		registration,
-		worker: navigator.serviceWorker.controller ?? active
+}
+async function* failing(err) {
+	throw err;
+}
+function teardownOnce(controller, notice, clock, inbound, output) {
+	let torn = false;
+	return () => {
+		if (torn) return;
+		torn = true;
+		if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: stream torn down"));
+		notice.post();
+		notice.stop();
+		clock.stop();
+		inbound.stop();
+		output?.return(void 0).catch(() => {});
 	};
 }
+function runCallerSide(port, input, options) {
+	const controller = new AbortController();
+	const notice = installAbortNotice(port, controller);
+	abortOnPortClose(port, controller);
+	const clock = installStreamTimeout(controller, options.timeout);
+	const inbound = receiveChunks(port, CHANNEL_OUT, controller, clock.touch);
+	const pump = sendChunks(port, CHANNEL_IN, input, options, controller.signal, clock.touch);
+	pump.catch(() => {});
+	return (async function* () {
+		try {
+			yield* inbound.stream;
+		} finally {
+			if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: the caller abandoned the stream"));
+			notice.post();
+			notice.stop();
+			clock.stop();
+			inbound.stop();
+			await pump.catch(() => {});
+			try {
+				await port.close?.();
+			} catch {}
+		}
+	})();
+}
 /**
-* Registers `handler` as the server for the given service `key` on the relay.
-* Returns a cleanup function that unregisters the service.
+* Listens for the peer's abort notice, and can post our own. The notice is a
+* plain message with no `channelName` and a `type` that is not `"request"`,
+* so neither `callPort` nor `listenPort` reacts to it, and it carries no
+* numeric `id`, so `structuredCodec` never mistakes it for a layer 1 envelope.
 */
-async function initHttpService(handler, { key, path, port }) {
-	return await registerConnectionsHandler({
-		key,
-		path,
-		communicationPort: port,
-		handler: async (_event, _data, callPort) => {
-			handleHttpRequests(callPort, handler);
-			return true;
+function installAbortNotice(port, controller) {
+	const onMessage = (event) => {
+		const data = event.data;
+		if (!data || data.type !== "webrun-rpc:stream-abort") return;
+		if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: the peer abandoned the stream"));
+	};
+	port.addEventListener("message", onMessage);
+	let posted = false;
+	return {
+		post() {
+			if (posted) return;
+			posted = true;
+			try {
+				port.postMessage({ type: STREAM_ABORT });
+			} catch {}
+		},
+		stop() {
+			port.removeEventListener("message", onMessage);
 		}
-	});
+	};
 }
 /**
-* Sends a `Request` to the service registered under `key` on the relay and
-* resolves with the corresponding `Response`.
+* Aborts the stream when its port closes underneath it — the multiplexer was
+* closed, or the peer closed the port — for ports that report it (see
+* `getPortCloseSignal`). Without this a stream waiting for the peer's next
+* chunk would wait forever on a port that can no longer deliver one: the
+* outbound half's `callPort` already fails on the close signal, but nothing
+* failed the inbound half.
 */
-async function callHttpService(request, { key, port }) {
-	const callPort = await initializeConnection({
-		key,
-		communicationPort: port
-	});
-	if (!callPort) throw new Error(`No service with key "${key}"`);
-	return await sendHttpRequest(callPort, request);
+function abortOnPortClose(port, controller) {
+	const closed = getPortCloseSignal(port);
+	if (!closed) return;
+	const onClose = () => {
+		if (!controller.signal.aborted) controller.abort(closed.reason);
+	};
+	if (closed.aborted) {
+		onClose();
+		return;
+	}
+	closed.addEventListener("abort", onClose, { once: true });
+	controller.signal.addEventListener("abort", () => closed.removeEventListener("abort", onClose), { once: true });
 }
 /**
-* Returns a `window.onmessage` handler for use inside the relay iframe:
-* it accepts a CONNECT message, starts the relay ServiceWorker, and bridges
-* the parent's MessagePort with the SW. If the worker cannot be started, every
-* call the parent makes on that port is answered with the error, so the
-* parent's `initHttpService` / `callHttpService` reject instead of waiting.
+* The per-stream inactivity timeout (spec D8). Reset by any chunk in either
+* direction; elapsing aborts the stream. Unset, zero or non-finite installs no
+* timer at all, which is the default: a slow consumer is throttled, not failed.
 */
-function getRelayWindowMessageHandler({ swUrl = `${new URL("./index-sw.js", moduleUrl)}`, scopeUrl = `${new URL("../", moduleUrl)}`, timeout } = {}) {
-	let externalPort;
-	return async (ev) => {
+function installStreamTimeout(controller, timeout) {
+	if (timeout === void 0 || !Number.isFinite(timeout) || timeout <= 0) return {
+		touch() {},
+		stop() {}
+	};
+	let timer;
+	let stopped = false;
+	const arm = () => {
+		timer = setTimeout(() => {
+			if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error(`webrun-rpc: stream idle for ${timeout} ms`));
+		}, timeout);
+	};
+	arm();
+	return {
+		touch() {
+			if (stopped) return;
+			if (timer !== void 0) clearTimeout(timer);
+			arm();
+		},
+		stop() {
+			stopped = true;
+			if (timer !== void 0) clearTimeout(timer);
+			timer = void 0;
+		}
+	};
+}
+/**
+* The receiving half of one direction.
+*
+* The `listenPort` listener is installed **eagerly**, not lazily inside
+* `recieveIterator`'s installer, because a handler that never drains its input
+* would otherwise leave the peer's chunk calls with nobody to answer them. If
+* the local consumer has not started iterating, an inbound chunk waits for it —
+* which is the correct backpressure, and different from having no listener.
+*/
+function receiveChunks(port, channelName, controller, touch) {
+	let deliver;
+	const waiting = [];
+	let finished = false;
+	let outstanding = false;
+	let poison;
+	let resolveEnded = () => {};
+	const ended = new Promise((resolve) => {
+		resolveEnded = resolve;
+	});
+	let aborted = false;
+	let abortReason;
+	const ready = () => deliver || finished ? Promise.resolve() : new Promise((r) => waiting.push(r));
+	const wake = () => {
+		for (const r of waiting.splice(0)) r();
+	};
+	const off = listenPort(port, async ({ done, value, error }) => {
+		touch();
+		if (poison) throw poison;
+		if (outstanding) {
+			poison = /* @__PURE__ */ new Error("webrun-rpc: peer sent a second unconfirmed chunk; the stream port is closed");
+			controller.abort(poison);
+			setTimeout(() => {
+				try {
+					port.close?.();
+				} catch {}
+			}, 0);
+			throw poison;
+		}
+		outstanding = true;
+		try {
+			await ready();
+			if (finished) throw poison ?? /* @__PURE__ */ new Error("webrun-rpc: the stream is closed");
+			await deliver?.({
+				done,
+				value,
+				error: error ? deserializeError(error) : void 0
+			});
+		} finally {
+			outstanding = false;
+		}
+		if (done) resolveEnded();
+	}, { channelName });
+	const detach = () => {
+		finished = true;
+		wake();
+		off();
+		controller.signal.removeEventListener("abort", onAbort);
+		resolveEnded();
+	};
+	const onAbort = () => {
+		aborted = true;
+		abortReason = controller.signal.reason;
+		finished = true;
+		wake();
+		deliver?.({
+			done: true,
+			error: abortReason
+		});
+		resolveEnded();
+	};
+	controller.signal.addEventListener("abort", onAbort, { once: true });
+	return {
+		stream: recieveIterator((d) => {
+			if (aborted) {
+				d({
+					done: true,
+					error: abortReason
+				});
+				return detach;
+			}
+			deliver = d;
+			wake();
+			return detach;
+		}),
+		stop: detach,
+		ended
+	};
+}
+/**
+* The sending half of one direction: one `callPort` per chunk, one call
+* outstanding at a time (spec D11/D12), with no per-chunk deadline (spec D8).
+*/
+async function sendChunks(port, channelName, output, { maxMessageSize, log }, signal, touch) {
+	const stream = throughAbort(maxMessageSize ? toChunks(maxMessageSize)(output) : output, signal);
+	try {
+		await sendIterator(async ({ done, value, error }) => {
+			if (signal.aborted) return;
+			const chunk = {
+				done,
+				value,
+				error: error === void 0 ? void 0 : serializeError(error)
+			};
+			log?.("[duplexOverPort] send", {
+				channelName,
+				done,
+				size: value?.byteLength
+			});
+			await callPort(port, chunk, {
+				channelName,
+				timeout: NO_TIMEOUT,
+				signal
+			});
+			touch();
+		}, stream);
+	} catch (err) {
+		if (signal.aborted) return;
+		throw err;
+	}
+}
+/**
+* One virtual port.
+*
+* `deliver` and `markClosed` are deliberately not on `port`: the consumer holds
+* only a `MessageTarget`, so it cannot forge inbound traffic or close the port
+* out from under the multiplexer's bookkeeping.
+*/
+function newVirtualPort(send, requestClose) {
+	const listeners = /* @__PURE__ */ new Set();
+	let closed = false;
+	const closing = new AbortController();
+	const abort = (reason) => {
+		if (closing.signal.aborted) return;
+		closing.abort(reason ?? /* @__PURE__ */ new Error("webrun-rpc: the port was closed"));
+	};
+	const port = {
+		addEventListener(_type, listener) {
+			listeners.add(listener);
+		},
+		removeEventListener(_type, listener) {
+			listeners.delete(listener);
+		},
+		postMessage(message, transfer) {
+			if (closed) return;
+			send(message, transfer);
+		},
+		close() {
+			if (closed) return;
+			closed = true;
+			const notify = requestClose;
+			listeners.clear();
+			notify();
+			abort();
+		}
+	};
+	setPortCloseSignal(port, closing.signal);
+	return {
+		port,
+		deliver(payload) {
+			if (closed) return;
+			const event = new MessageEvent("message", { data: payload });
+			for (const listener of [...listeners]) try {
+				listener(event);
+			} catch {}
+		},
+		markClosed(reason) {
+			closed = true;
+			listeners.clear();
+			abort(reason);
+		},
+		isClosed() {
+			return closed;
+		}
+	};
+}
+/**
+* The message of the error that fails the calls still in flight on a
+* multiplexer when it is closed (`PortMux.close()`).
+*/
+const MUX_CLOSED_MESSAGE = "webrun-rpc: the multiplexer was closed";
+/** Ceiling on concurrently open virtual ports. Bounds the id table only. */
+const DEFAULT_MAX_PORTS = 1024;
+/**
+* The default `PortMux`: emulates multiplexing over a single port.
+*
+* A transport that already multiplexes natively supplies its own `PortMux`
+* instead — this implementation is for transports that offer one pipe.
+*/
+function multiplexPort(port, options) {
+	const { codec, onPort, side = "initiator", maxPorts = DEFAULT_MAX_PORTS, maxMessageSize } = options;
+	const open = /* @__PURE__ */ new Map();
+	let nextId = side === "initiator" ? 0 : 1;
+	let muxClosed = false;
+	const post = (envelope, transfer) => {
+		if (muxClosed) return;
+		try {
+			codec.post(port, envelope, transfer);
+		} catch {}
+	};
+	const attach = (id) => {
+		let self;
+		self = newVirtualPort((payload, transfer) => post({
+			type: "message",
+			id,
+			payload
+		}, transfer), (reason) => {
+			post({
+				type: "close",
+				id,
+				reason
+			});
+			open.delete(id);
+			self.markClosed();
+		});
+		open.set(id, self);
+		return self;
+	};
+	const handleEnvelope = (envelope) => {
+		if (muxClosed) return;
+		if (envelope.type === "open") {
+			if (open.has(envelope.id)) return;
+			if (open.size >= maxPorts) {
+				post({
+					type: "close",
+					id: envelope.id,
+					reason: "max-ports"
+				});
+				return;
+			}
+			const handle = attach(envelope.id);
+			let accepted = false;
+			if (onPort) try {
+				accepted = onPort(handle.port, envelope.meta) !== false;
+			} catch {
+				accepted = false;
+			}
+			if (!accepted) {
+				open.delete(envelope.id);
+				handle.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the port was rejected"));
+				post({
+					type: "close",
+					id: envelope.id,
+					reason: "rejected"
+				});
+			}
+			return;
+		}
+		const handle = open.get(envelope.id);
+		if (envelope.type === "message") {
+			if (!handle) return;
+			handle.deliver(envelope.payload);
+			return;
+		}
+		if (!handle) return;
+		open.delete(envelope.id);
+		handle.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the peer closed the port"));
+	};
+	const listener = (event) => {
+		const envelope = codec.read(event);
+		if (envelope) handleEnvelope(envelope);
+	};
+	port.addEventListener("message", listener);
+	port.start?.();
+	return {
+		maxMessageSize,
+		async openPort(meta) {
+			if (muxClosed) throw new Error("webrun-rpc: the multiplexer is closed");
+			if (open.size >= maxPorts) throw new RangeError(`webrun-rpc: maxPorts (${maxPorts}) reached`);
+			while (open.has(nextId)) nextId += 2;
+			const id = nextId;
+			nextId += 2;
+			const handle = attach(id);
+			post({
+				type: "open",
+				id,
+				meta
+			});
+			return handle.port;
+		},
+		async close() {
+			if (muxClosed) return;
+			for (const [id, handle] of [...open]) {
+				post({
+					type: "close",
+					id
+				});
+				open.delete(id);
+				handle.markClosed(/* @__PURE__ */ new Error(MUX_CLOSED_MESSAGE));
+			}
+			muxClosed = true;
+			port.removeEventListener("message", listener);
+			await port.close?.();
+		}
+	};
+}
+/**
+* Announced with every port this pair opens. Layer 1 never reads `meta` — it is
+* here so a peer running something else over the same multiplexer can tell a
+* stream port from whatever else it hands out, and so a packet capture says
+* what the port is for.
+*/
+const STREAM_META = { kind: "stream" };
+/**
+* One port source in, one caller `Duplex` out.
+*
+* A call is a port: the mux allocates one, `duplexOverPort` runs the single
+* invocation on it, and closing the stream closes the port. No stream ids, no
+* framing and no credit accounting live here — the mux owns the first, and
+* `duplexOverPort` owns the one-chunk window that makes memory bounded.
+*/
+const connect = async ({ mux: factory, timeout }) => {
+	const mux = await factory();
+	const streamOptions = {
+		maxMessageSize: mux.maxMessageSize,
+		timeout
+	};
+	const call = (input) => (async function* () {
+		yield* duplexOverPort(await mux.openPort(STREAM_META), streamOptions)(input);
+	})();
+	return {
+		call,
+		async close() {
+			await mux.close();
+		}
+	};
+};
+/**
+* One port source in, `handler` serving every call that arrives on it.
+*
+* Each inbound port is one invocation, so the factory's `onPort` is the accept
+* loop: it installs `handler` on the new port and nothing else. The returned
+* teardown abandons the streams still running *before* dropping the mux, so
+* the peer's callers reject with "the peer abandoned the stream" instead of
+* parking forever on a port that has silently gone inert — layer 1's close is
+* not observable to layer 2, which is why the notice has to be posted
+* deliberately.
+*/
+const serve = async ({ mux: factory, timeout }, handler) => {
+	const live = /* @__PURE__ */ new Set();
+	let streamOptions = { timeout };
+	const mux = await factory((port) => {
+		let off;
+		let finished = false;
+		const tracked = (input) => (async function* () {
+			try {
+				yield* handler(input);
+			} finally {
+				finished = true;
+				if (off) live.delete(off);
+			}
+		})();
+		off = serveDuplexOverPort(port, tracked, streamOptions);
+		if (!finished) live.add(off);
+	});
+	streamOptions = {
+		maxMessageSize: mux.maxMessageSize,
+		timeout
+	};
+	let torn = false;
+	return async () => {
+		if (torn) return;
+		torn = true;
+		for (const off of [...live]) {
+			live.delete(off);
+			try {
+				off();
+			} catch {}
+		}
+		await mux.close();
+	};
+};
+/**
+* Ports over ONE PIPE OF BYTES — a `MessagePort`, a worker, a WebSocket.
+*
+* There is no second port to be had, so `multiplexPort`'s id table invents
+* them. Use this when the transport gives you exactly one channel.
+*/
+function overPipe(pipe, options) {
+	return (onPort) => multiplexPort(pipe, {
+		...options,
+		onPort
+	});
+}
+function isEnvelope(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	if (typeof candidate.id !== "number") return false;
+	if (!Number.isInteger(candidate.id) || candidate.id < 0) return false;
+	return candidate.type === "open" || candidate.type === "message" || candidate.type === "close";
+}
+/**
+* For ports whose messages are structured values — a real `MessagePort`, a
+* worker, an iframe.
+*
+* Envelopes are posted as-is, so nothing is encoded, `ArrayBuffer`s move
+* zero-copy through the transfer list, and structured clone does the work the
+* platform already does well. This is a performance choice only: layer 2 may
+* not send anything a byte codec could not also carry.
+*/
+const structuredCodec = {
+	post(port, envelope, transfer) {
+		if (transfer && transfer.length > 0) port.postMessage(envelope, transfer);
+		else port.postMessage(envelope);
+	},
+	read(event) {
+		return isEnvelope(event.data) ? event.data : void 0;
+	}
+};
+//#endregion
+//#region src/link/http-link.ts
+/**
+* The version of the HTTP-over-`MessagePort` protocol this package speaks,
+* sent in every hand-shake that sets up a link. Version 1 was this package's
+* own `handleStreams` / `sendStream` (no backpressure); version 2 is
+* webrun-rpc's `connect` / `serve` over `overPipe` with webrun-http-streams'
+* `fetchOverDuplex` / `serveFetchOverDuplex`: one port per link, calls
+* multiplexed on it, each call a stream with a one-chunk window in both
+* directions, and cancellation that reaches the handler.
+*/
+const HTTP_LINK_PROTOCOL = "webrun-http-link/2";
+/**
+* Why a request failed when its link went away under it: the far side (the
+* handler, or the ServiceWorker) was lost. The request may or may not have
+* been applied.
+*/
+var LinkLostError = class extends Error {
+	constructor(message = "The link was lost while this request was in flight") {
+		super(`${message}; it may or may not have been applied.`);
+		this.name = "LinkLostError";
+	}
+};
+/**
+* Posted on a link's port by the calling end when it closes the link, so the
+* answering end can release it: a `MessagePort` never reports that its other
+* end is gone.
+*/
+const LINK_CLOSE = "webrun-http:link-close";
+/** Opens the calling end of a link on `port` (one port per link). */
+async function connectHttpLink(port, { streamTimeout } = {}) {
+	const { call, close } = await connect({
+		mux: overPipe(port, {
+			codec: structuredCodec,
+			side: "initiator"
+		}),
+		timeout: streamTimeout
+	});
+	return trackedLink((request) => fetchOverDuplex(call, request), async () => {
+		try {
+			port.postMessage({ type: LINK_CLOSE });
+		} catch {}
+		await close();
+	});
+}
+/**
+* Serves `handler` on the answering end of a link. Resolves with a teardown
+* that abandons the requests still running (their handlers see the
+* cancellation) and releases the port.
+*/
+async function serveHttpLink(port, handler, { streamTimeout } = {}) {
+	const teardown = await serve({
+		mux: overPipe(port, {
+			codec: structuredCodec,
+			side: "responder"
+		}),
+		timeout: streamTimeout
+	}, serveFetchOverDuplex(async (request) => await handler(request)));
+	const onClose = (event) => {
+		if (event.data?.type === LINK_CLOSE) close();
+	};
+	const close = async () => {
+		port.removeEventListener("message", onClose);
+		await teardown();
+	};
+	port.addEventListener("message", onClose);
+	return close;
+}
+/**
+* Wraps a `send` so the link knows its requests in flight (for draining and
+* load-based routing) and can fail them all at once when it is closed.
+*/
+function trackedLink(send, release) {
+	let inflight = 0;
+	let closed = false;
+	let lostReason;
+	const failers = /* @__PURE__ */ new Set();
+	const idleWaiters = [];
+	const done = () => {
+		inflight--;
+		if (inflight === 0) for (const resolve of idleWaiters.splice(0)) resolve();
+	};
+	return {
+		get inflight() {
+			return inflight;
+		},
+		get closed() {
+			return closed;
+		},
+		whenIdle() {
+			return inflight === 0 ? Promise.resolve() : new Promise((r) => idleWaiters.push(r));
+		},
+		async send(request) {
+			if (closed) throw lostReason ?? new LinkLostError("The link is closed");
+			inflight++;
+			let finished = false;
+			const finish = () => {
+				if (finished) return;
+				finished = true;
+				failers.delete(fail);
+				done();
+			};
+			let fail = () => {};
+			const lost = new Promise((_, reject) => {
+				fail = reject;
+			});
+			failers.add(fail);
+			lost.catch(() => {});
+			let response;
+			try {
+				response = await Promise.race([send(request), lost]);
+			} catch (error) {
+				finish();
+				throw lostReason ?? error;
+			}
+			if (!response.body) {
+				finish();
+				return response;
+			}
+			return new Response(guardBody(response.body, lost, () => lostReason, finish), {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers
+			});
+		},
+		async close(reason) {
+			if (closed) return;
+			closed = true;
+			lostReason = reason ?? new LinkLostError("The link was closed");
+			for (const fail of [...failers]) fail(lostReason);
+			try {
+				await release();
+			} catch {}
+		}
+	};
+}
+/**
+* A response body that reports its end (done, cancelled or failed) and fails
+* with the link's reason when the link is lost mid-stream.
+*/
+function guardBody(body, lost, reason, finish) {
+	const reader = body.getReader();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await Promise.race([reader.read(), lost]);
+				if (done) {
+					finish();
+					controller.close();
+					return;
+				}
+				controller.enqueue(value);
+			} catch (error) {
+				finish();
+				reader.cancel().catch(() => {});
+				controller.error(reason() ?? error);
+			}
+		},
+		async cancel(why) {
+			finish();
+			await reader.cancel(why).catch(() => {});
+		}
+	});
+}
+//#endregion
+//#region src/link/locks.ts
+function lockManager() {
+	return globalThis.navigator?.locks;
+}
+function locksAvailable() {
+	return lockManager() !== void 0;
+}
+/** A fresh lock name: `<prefix>:<uuid>`. */
+function newLockName(prefix) {
+	return `${prefix}:${crypto.randomUUID()}`;
+}
+/**
+* Takes the lock `name` and holds it until the returned release is called or
+* this context dies. Resolves once the lock is held; with no Web Locks,
+* resolves at once.
+*/
+async function holdLock(name) {
+	const locks = lockManager();
+	if (!locks) return () => {};
+	let release = () => {};
+	const released = new Promise((resolve) => {
+		release = resolve;
+	});
+	await new Promise((held) => {
+		locks.request(name, {}, () => {
+			held();
+			return released;
+		}).catch(() => held());
+	});
+	return release;
+}
+/**
+* Calls `onLost` once the lock `name` is granted to this context — that is,
+* once whoever holds it is gone — and releases it at once. Returns a function
+* that stops watching. With no Web Locks, never calls `onLost`.
+*/
+function watchLock(name, onLost) {
+	const locks = lockManager();
+	if (!locks) return () => {};
+	const controller = new AbortController();
+	locks.request(name, { signal: controller.signal }, () => {
+		if (!controller.signal.aborted) onLost();
+	}).catch(() => {});
+	return () => controller.abort();
+}
+/**
+* The names of the locks held right now in this origin, or `undefined` where
+* that cannot be asked. A backup for `watchLock`: a grant can be late, a query
+* cannot.
+*/
+async function heldLockNames() {
+	const locks = lockManager();
+	if (!locks?.query) return void 0;
+	try {
+		const { held = [] } = await locks.query();
+		return new Set(held.map((lock) => lock.name ?? ""));
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/link/rendezvous.ts
+/**
+* Matches replies to requests by id, for the control messages that hand
+* WebSocket ports across: each waiting request has a deadline, and all of a
+* peer's waiting requests can be failed at once when the peer is lost.
+*/
+var PortRendezvous = class {
+	_prefix;
+	_waiting = /* @__PURE__ */ new Map();
+	_counter = 0;
+	constructor(_prefix = "r") {
+		this._prefix = _prefix;
+	}
+	/** A fresh id for a request. */
+	newId() {
+		return `${this._prefix}:${++this._counter}`;
+	}
+	get size() {
+		return this._waiting.size;
+	}
+	/** Waits for the reply to `id`, failing after `timeoutMs`. */
+	wait(id, timeoutMs, describe = "the reply") {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this._waiting.delete(id);
+				reject(/* @__PURE__ */ new Error(`No answer to ${describe} within ${timeoutMs} ms`));
+			}, timeoutMs);
+			this._waiting.set(id, {
+				resolve,
+				reject,
+				timer
+			});
+		});
+	}
+	/** Delivers the reply to `id`. `false` when nobody waits for it (it timed out). */
+	settle(id, value) {
+		const waiting = this._waiting.get(id);
+		if (!waiting) return false;
+		this._waiting.delete(id);
+		clearTimeout(waiting.timer);
+		waiting.resolve(value);
+		return true;
+	}
+	fail(id, error) {
+		const waiting = this._waiting.get(id);
+		if (!waiting) return;
+		this._waiting.delete(id);
+		clearTimeout(waiting.timer);
+		waiting.reject(error);
+	}
+	failAll(error) {
+		for (const id of [...this._waiting.keys()]) this.fail(id, error);
+	}
+};
+//#endregion
+//#region src/ws/frames.ts
+/**
+* The wire protocol of a WebSocket carried over a `MessagePort`.
+*
+* A `MessagePort` is a natural carrier for a WebSocket: messages arrive in
+* order, and strings and transferable `ArrayBuffer`s cross it as they are. The
+* protocol on top is these frames, the same in both directions:
+*
+* - `m` — one message. An `ArrayBuffer` is transferred, never copied.
+* - `c` — close. The side that closes first sends it; the other answers with
+*   its own `c` (the echo), and both are then closed cleanly.
+* - `p` — ping, client to server, carrying the client's heartbeat period.
+* - `q` — pong, server to client.
+* - `a` — ack: the receiver consumed `n` more bytes of messages. This is the
+*   flow control: what a side has sent and not yet seen acknowledged is its
+*   `bufferedAmount`, and the server end can wait for it to fall
+*   (`whenDrained`). Added in version 2; version 1 had no backpressure.
+*
+* HEARTBEAT. A `MessagePort` never reports that the other side died, so the
+* client pings every `hb` ms and closes with 1006 when pongs stop for `2·hb`;
+* the server closes with 1006 when pings stop for `3·hb`. That is how a socket
+* notices a closed tab or a terminated worker.
+*
+* Unknown frames are ignored, so a later version can add frames a peer of
+* this version skips.
+*/
+/** The version of this frame protocol. Sent in the upgrade hand-shake. */
+const WS_PORT_PROTOCOL_VERSION = 2;
+/** Default heartbeat period of the client, in ms. */
+const DEFAULT_HEARTBEAT_MS = 1e4;
+/** How long a side waits for the echo of its close frame, in ms. */
+const DEFAULT_CLOSE_TIMEOUT_MS = 5e3;
+const defaultTimers = {
+	setTimeout: (fn, ms) => setTimeout(fn, ms),
+	clearTimeout: (id) => clearTimeout(id),
+	setInterval: (fn, ms) => setInterval(fn, ms),
+	clearInterval: (id) => clearInterval(id)
+};
+/** Recovers a frame from a message's data, or `undefined` for anything else. */
+function readFrame(data) {
+	if (typeof data !== "object" || data === null) return void 0;
+	const frame = data;
+	switch (frame.t) {
+		case "m": return typeof frame.d === "string" || frame.d instanceof ArrayBuffer ? frame : void 0;
+		case "c": return {
+			t: "c",
+			code: typeof frame.code === "number" ? frame.code : 1005,
+			reason: typeof frame.reason === "string" ? frame.reason : ""
+		};
+		case "p": {
+			const hb = frame.hb;
+			return {
+				t: "p",
+				hb: typeof hb === "number" && hb > 0 ? hb : DEFAULT_HEARTBEAT_MS
+			};
+		}
+		case "q": return { t: "q" };
+		case "a": {
+			const n = frame.n;
+			return typeof n === "number" && n >= 0 ? {
+				t: "a",
+				n
+			} : void 0;
+		}
+		default: return;
+	}
+}
+/** Posts `frame`, transferring a message's `ArrayBuffer`. */
+function postFrame(port, frame) {
+	if (frame.t === "m" && frame.d instanceof ArrayBuffer) port.postMessage(frame, [frame.d]);
+	else port.postMessage(frame);
+}
+/** The size a message counts for in `bufferedAmount`: UTF-8 bytes, or the buffer's length. */
+function messageSize(data) {
+	return typeof data === "string" ? utf8Length(data) : data.byteLength;
+}
+/** The UTF-8 length of `text`, without encoding it. */
+function utf8Length(text) {
+	let length = 0;
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code < 128) length += 1;
+		else if (code < 2048) length += 2;
+		else if (code >= 55296 && code <= 56319 && i + 1 < text.length) {
+			const next = text.charCodeAt(i + 1);
+			if (next >= 56320 && next <= 57343) {
+				length += 4;
+				i++;
+			} else length += 3;
+		} else length += 3;
+	}
+	return length;
+}
+/**
+* A `CloseEvent` for runtimes that have none: Node 22 has `Event` and
+* `MessageEvent` as globals, but not `CloseEvent`.
+*/
+var WsCloseEvent = class extends Event {
+	code;
+	reason;
+	wasClean;
+	constructor(type, init = {}) {
+		super(type, init);
+		this.code = init.code ?? 0;
+		this.reason = init.reason ?? "";
+		this.wasClean = init.wasClean ?? false;
+	}
+};
+/** A `close` event: the platform's `CloseEvent` where there is one. */
+function newCloseEvent(init) {
+	const Native = globalThis.CloseEvent;
+	return Native ? new Native("close", init) : new WsCloseEvent("close", init);
+}
+/**
+* What both ends of a socket over a `MessagePort` share: the frames, the close
+* handshake, and the byte accounting behind `bufferedAmount`.
+*
+* Not exported from the package: the two ends are `createWebSocketClass`'s
+* class and `ServerWebSocket`.
+*/
+var PortSocketCore = class extends EventTarget {
+	_port;
+	_state = 0;
+	_timers;
+	_closeTimeoutMs;
+	/** Bytes sent and not yet acknowledged by the peer, plus those still being prepared. */
+	_inFlight = 0;
+	/** Bytes of messages "sent" after the socket started closing: counted, never sent. */
+	_discarded = 0;
+	_toAck = 0;
+	_ackScheduled = false;
+	_closeTimer;
+	_drainWaiters = [];
+	constructor(options = {}) {
+		super();
+		this._timers = options.timers ?? defaultTimers;
+		this._closeTimeoutMs = options.closeTimeoutMs ?? 5e3;
+	}
+	get readyState() {
+		return this._state;
+	}
+	/**
+	* Bytes queued by `send()` that the peer has not consumed yet. A peer
+	* acknowledges what it has dispatched, so this falls as the other side reads.
+	*/
+	get bufferedAmount() {
+		return this._inFlight + this._discarded;
+	}
+	/**
+	* Resolves once `bufferedAmount` is at most `limit` (default 0), or the
+	* socket is closed. The backpressure a producer applies:
+	* `if (socket.bufferedAmount > HIGH) await socket.whenDrained(LOW)`.
+	*/
+	whenDrained(limit = 0) {
+		if (this._state === 3 || this._inFlight <= limit) return Promise.resolve();
+		return new Promise((resolve) => this._drainWaiters.push({
+			limit,
+			resolve
+		}));
+	}
+	_attach(port) {
+		this._port = port;
+		port.onmessage = (event) => {
+			const frame = readFrame(event.data);
+			if (frame) this._onFrame(frame);
+		};
+	}
+	_onFrame(frame) {
+		switch (frame.t) {
+			case "m":
+			case "c":
+				this._deliver(frame);
+				return;
+			case "a":
+				this._inFlight = Math.max(0, this._inFlight - frame.n);
+				this._wakeDrainWaiters();
+				return;
+			case "p":
+				this._onPing(frame.hb);
+				return;
+			case "q":
+				this._onPong();
+				return;
+		}
+	}
+	/** A message or close frame the socket is ready to act on. */
+	_deliver(frame) {
+		if (frame.t === "c") {
+			this._onCloseFrame(frame.code, frame.reason);
+			return;
+		}
+		if (this._state !== 1) return;
+		this._dispatchMessage(frame.d);
+		this._consumed(messageSize(frame.d));
+	}
+	_onPing(_hb) {}
+	_onPong() {}
+	_onClosed() {}
+	/** Acknowledge consumed bytes, coalescing the acks of one turn into one frame. */
+	_consumed(bytes) {
+		this._toAck += bytes;
+		if (this._ackScheduled) return;
+		this._ackScheduled = true;
+		queueMicrotask(() => {
+			this._ackScheduled = false;
+			const n = this._toAck;
+			this._toAck = 0;
+			if (n > 0 && this._state !== 3) this._post({
+				t: "a",
+				n
+			});
+		});
+	}
+	/** Reserves `bytes` in `bufferedAmount` for a message still being prepared (a Blob). */
+	_reserve(bytes) {
+		this._inFlight += bytes;
+	}
+	/** Sends one message whose bytes were reserved with `_reserve` (or `reserved = false`). */
+	_sendData(data, reserved = false) {
+		const size = messageSize(data);
+		if (this._state !== 1) {
+			if (reserved) this._inFlight = Math.max(0, this._inFlight - size);
+			this._discarded += size;
+			return;
+		}
+		if (!reserved) this._inFlight += size;
+		this._post({
+			t: "m",
+			d: data
+		});
+	}
+	_post(frame) {
+		try {
+			if (this._port) postFrame(this._port, frame);
+		} catch {}
+	}
+	/** Starts the close handshake. */
+	_startClose(code, reason) {
+		if (this._state === 2 || this._state === 3) return;
+		this._state = 2;
+		this._post({
+			t: "c",
+			code,
+			reason
+		});
+		this._closeTimer = this._timers.setTimeout(() => this._finish(1006, "", false), this._closeTimeoutMs);
+	}
+	_onCloseFrame(code, reason) {
+		if (this._state === 3) return;
+		if (this._state === 2) {
+			this._finish(code, reason, true);
+			return;
+		}
+		this._state = 2;
+		this._post({
+			t: "c",
+			code,
+			reason
+		});
+		this._finish(code, reason, true);
+	}
+	/** The socket is closed: release the port and tell the listeners. */
+	_finish(code, reason, wasClean, error = false) {
+		if (this._state === 3) return;
+		this._state = 3;
+		if (this._closeTimer !== void 0) this._timers.clearTimeout(this._closeTimer);
+		this._closeTimer = void 0;
+		this._onClosed();
+		if (this._port) {
+			this._port.onmessage = null;
+			try {
+				this._port.close();
+			} catch {}
+		}
+		this._wakeDrainWaiters();
+		if (error) this.dispatchEvent(new Event("error"));
+		this.dispatchEvent(newCloseEvent({
+			code,
+			reason,
+			wasClean
+		}));
+	}
+	_wakeDrainWaiters() {
+		if (this._drainWaiters.length === 0) return;
+		const closed = this._state === 3;
+		this._drainWaiters = this._drainWaiters.filter(({ limit, resolve }) => {
+			if (!closed && this._inFlight > limit) return true;
+			resolve();
+			return false;
+		});
+	}
+};
+/** Copies `data` into a fresh `ArrayBuffer`: `send()` must never detach the caller's buffer. */
+function toArrayBuffer(data) {
+	if (data instanceof ArrayBuffer) return data.slice(0);
+	const copy = new Uint8Array(data.byteLength);
+	copy.set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+	return copy.buffer;
+}
+function isBinary(data) {
+	return data instanceof ArrayBuffer || ArrayBuffer.isView(data);
+}
+function isBlob(data) {
+	return typeof Blob !== "undefined" && data instanceof Blob;
+}
+/** Valid close codes for an application to send: 1000, or 3000–4999. */
+function isApplicationCloseCode(code) {
+	return code === 1e3 || code >= 3e3 && code <= 4999;
+}
+//#endregion
+//#region src/ws/client.ts
+/** RFC 7230 `token`: what a subprotocol name may be. */
+const TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/**
+* A WHATWG-compatible `WebSocket` class whose transport is a `MessagePort`
+* from `connect`. Code written against the browser's `WebSocket` runs on it
+* unchanged:
+*
+* ```ts
+* const WS = createWebSocketClass(adapter.connectWebSocket);
+* const ws = new WS(`${baseUrl}chat`, ["v1"]);
+* ws.onmessage = (event) => console.log(event.data);
+* ```
+*
+* It validates as the standard does (url, scheme, fragment, subprotocol
+* tokens and duplicates, close codes and reasons), has `binaryType`, the `on*`
+* handlers next to `addEventListener`, and the close handshake.
+* `bufferedAmount` is real: the server acknowledges what it consumed.
+*
+* The real `globalThis.WebSocket` is left alone; install the class where you
+* want it.
+*/
+function createWebSocketClass(connect, options = {}) {
+	const heartbeatMs = options.heartbeatMs ?? 1e4;
+	class WebSocketOverPort extends PortSocketCore {
+		static CONNECTING = 0;
+		static OPEN = 1;
+		static CLOSING = 2;
+		static CLOSED = 3;
+		CONNECTING = 0;
+		OPEN = 1;
+		CLOSING = 2;
+		CLOSED = 3;
+		url;
+		extensions = "";
+		_protocol = "";
+		_binaryType = "blob";
+		_handlers = {};
+		_heartbeat;
+		/** When the oldest ping still waiting for its pong was sent. */
+		_unansweredSince;
+		_onVisibility;
+		/** Sends waiting for a Blob ahead of them to be read, so order is kept. */
+		_chain;
+		constructor(url, protocols = []) {
+			super({
+				timers: options.timers,
+				closeTimeoutMs: options.closeTimeoutMs
+			});
+			this.url = parseUrl(url);
+			const list = typeof protocols === "string" ? [protocols] : [...protocols];
+			validateProtocols(list);
+			for (const type of [
+				"open",
+				"message",
+				"error",
+				"close"
+			]) this.addEventListener(type, (event) => this._handlers[type]?.call(this, event));
+			Promise.resolve().then(() => connect(this.url, list)).then((connection) => {
+				try {
+					this._opened(connection, list);
+				} catch {
+					this._failed();
+				}
+			}, () => this._failed());
+		}
+		get protocol() {
+			return this._protocol;
+		}
+		get binaryType() {
+			return this._binaryType;
+		}
+		set binaryType(value) {
+			if (value === "blob" || value === "arraybuffer") this._binaryType = value;
+		}
+		get onopen() {
+			return this._handlers.open ?? null;
+		}
+		set onopen(fn) {
+			this._handlers.open = typeof fn === "function" ? fn : null;
+		}
+		get onmessage() {
+			return this._handlers.message ?? null;
+		}
+		set onmessage(fn) {
+			this._handlers.message = typeof fn === "function" ? fn : null;
+		}
+		get onerror() {
+			return this._handlers.error ?? null;
+		}
+		set onerror(fn) {
+			this._handlers.error = typeof fn === "function" ? fn : null;
+		}
+		get onclose() {
+			return this._handlers.close ?? null;
+		}
+		set onclose(fn) {
+			this._handlers.close = typeof fn === "function" ? fn : null;
+		}
+		send(data) {
+			if (this._state === 0) throw new DOMException("Still in CONNECTING state.", "InvalidStateError");
+			if (isBlob(data)) {
+				const size = data.size;
+				if (this._state !== 1) {
+					this._sendData(new ArrayBuffer(size));
+					return;
+				}
+				this._reserve(size);
+				this._enqueue(async () => this._sendData(await data.arrayBuffer(), true));
+				return;
+			}
+			const payload = isBinary(data) ? toArrayBuffer(data) : String(data);
+			if (this._chain) this._enqueue(async () => this._sendData(payload));
+			else this._sendData(payload);
+		}
+		close(code, reason) {
+			if (code !== void 0 && !isApplicationCloseCode(code)) throw new DOMException(`The close code must be 1000 or in 3000-4999; ${code} is neither.`, "InvalidAccessError");
+			const text = reason ?? "";
+			if (utf8Length(text) > 123) throw new DOMException("The close reason is longer than 123 bytes.", "SyntaxError");
+			if (this._state === 2 || this._state === 3) return;
+			if (this._state === 0) {
+				this._state = 2;
+				return;
+			}
+			this._startClose(code ?? 1005, text);
+		}
+		_dispatchMessage(data) {
+			const value = typeof data === "string" || this._binaryType === "arraybuffer" ? data : new Blob([data]);
+			this.dispatchEvent(new MessageEvent("message", {
+				data: value,
+				origin: new URL(this.url).origin
+			}));
+		}
+		_onPong() {
+			this._unansweredSince = void 0;
+		}
+		_onClosed() {
+			if (this._heartbeat !== void 0) this._timers.clearInterval(this._heartbeat);
+			this._heartbeat = void 0;
+			if (this._onVisibility) globalThis.document?.removeEventListener("visibilitychange", this._onVisibility);
+		}
+		_ping(hb = heartbeatMs) {
+			this._unansweredSince ??= Date.now();
+			this._post({
+				t: "p",
+				hb
+			});
+		}
+		_opened(connection, requested) {
+			const { port, protocol = "" } = connection ?? {};
+			if (!port || typeof port.postMessage !== "function") {
+				this._failed();
+				return;
+			}
+			if (this._state !== 0) {
+				try {
+					port.postMessage({
+						t: "c",
+						code: 1006,
+						reason: ""
+					});
+					port.close();
+				} catch {}
+				this._finish(1006, "", false, true);
+				return;
+			}
+			if (protocol !== "" && !requested.includes(protocol)) {
+				port.close();
+				this._failed();
+				return;
+			}
+			this._protocol = protocol;
+			this._attach(port);
+			this._state = 1;
+			this._ping();
+			this._heartbeat = this._timers.setInterval(() => {
+				const since = this._unansweredSince;
+				if (since !== void 0 && Date.now() - since > 2 * heartbeatMs) {
+					this._finish(1006, "", false, true);
+					return;
+				}
+				this._ping();
+			}, heartbeatMs);
+			const doc = globalThis.document;
+			if (doc) {
+				this._onVisibility = () => this._ping(doc.visibilityState === "hidden" ? Math.max(heartbeatMs, 7e4) : heartbeatMs);
+				doc.addEventListener("visibilitychange", this._onVisibility);
+				if (doc.visibilityState === "hidden") this._onVisibility();
+			}
+			this.dispatchEvent(new Event("open"));
+		}
+		_failed() {
+			this._state = 2;
+			this._finish(1006, "", false, true);
+		}
+		_enqueue(task) {
+			const run = (this._chain ?? Promise.resolve()).then(task).catch(() => {});
+			this._chain = run;
+			run.then(() => {
+				if (this._chain === run) this._chain = void 0;
+			});
+		}
+	}
+	return WebSocketOverPort;
+}
+function parseUrl(input) {
+	let url;
+	try {
+		url = new URL(`${input}`, globalThis.location?.href);
+	} catch {
+		throw new DOMException(`The URL '${input}' is invalid.`, "SyntaxError");
+	}
+	if (url.protocol === "http:") url.protocol = "ws:";
+	else if (url.protocol === "https:") url.protocol = "wss:";
+	if (url.protocol !== "ws:" && url.protocol !== "wss:") throw new DOMException(`The URL's scheme must be 'ws', 'wss', 'http' or 'https'; '${url.protocol.slice(0, -1)}' is not allowed.`, "SyntaxError");
+	if (url.hash !== "" || `${input}`.includes("#")) throw new DOMException(`The URL contains a fragment identifier ('${url.hash}'). Fragment identifiers are not allowed in WebSocket URLs.`, "SyntaxError");
+	return url.href;
+}
+function validateProtocols(protocols) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const protocol of protocols) {
+		if (!TOKEN.test(protocol)) throw new DOMException(`The subprotocol '${protocol}' is invalid.`, "SyntaxError");
+		if (seen.has(protocol)) throw new DOMException(`The subprotocol '${protocol}' is duplicated.`, "SyntaxError");
+		seen.add(protocol);
+	}
+}
+//#endregion
+//#region src/link/errors.ts
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/ws/server.ts
+/**
+* The server end of a socket over a `MessagePort`: what a handler gets from
+* `upgradeWebSocket` and talks to.
+*
+* - Events are delivered only after `accept()`; frames that arrive earlier are
+*   queued. Pings are answered even before `accept()`, so a slow handler does
+*   not look like a dead one.
+* - Messages arrive as strings or `ArrayBuffer`s.
+* - `bufferedAmount` counts what the client has not consumed yet, and
+*   `whenDrained(limit)` waits for it to fall: the backpressure a producer
+*   applies.
+* - When the client's pings stop for three heartbeat periods (a closed tab, a
+*   terminated worker), the socket closes with 1006.
+*/
+var ServerWebSocket = class extends PortSocketCore {
+	static CONNECTING = 0;
+	static OPEN = 1;
+	static CLOSING = 2;
+	static CLOSED = 3;
+	url;
+	protocol;
+	_accepted = false;
+	_queue = [];
+	_heartbeatMs = DEFAULT_HEARTBEAT_MS;
+	_lastPing = Date.now();
+	_watch;
+	constructor(port, options = {}) {
+		super({
+			timers: options.timers,
+			closeTimeoutMs: options.closeTimeoutMs
+		});
+		this.url = options.url ?? "";
+		this.protocol = options.protocol ?? "";
+		this._attach(port);
+		this._state = 1;
+		this._watchHeartbeat();
+	}
+	/** Whether `accept()` was called. */
+	get accepted() {
+		return this._accepted;
+	}
+	/** Starts delivering events, the queued ones first. */
+	accept() {
+		if (this._accepted) return;
+		this._accepted = true;
+		for (const frame of this._queue.splice(0)) super._deliver(frame);
+	}
+	send(data) {
+		if (!this._accepted) throw new DOMException("accept() the socket before sending on it.", "InvalidStateError");
+		this._sendData(isBinary(data) ? toArrayBuffer(data) : String(data));
+	}
+	close(code = 1e3, reason = "") {
+		if (!isSendableCloseCode(code)) throw new DOMException(`${code} is not a close code an endpoint may send.`, "InvalidAccessError");
+		if (utf8Length(reason) > 123) throw new DOMException("The close reason is longer than 123 bytes.", "SyntaxError");
+		this._startClose(code, reason);
+	}
+	_deliver(frame) {
+		if (!this._accepted) {
+			this._queue.push(frame);
+			return;
+		}
+		super._deliver(frame);
+	}
+	_dispatchMessage(data) {
+		this.dispatchEvent(new MessageEvent("message", { data }));
+	}
+	_onPing(hb) {
+		this._post({ t: "q" });
+		this._lastPing = Date.now();
+		if (hb !== this._heartbeatMs) {
+			this._heartbeatMs = hb;
+			this._watchHeartbeat();
+		}
+	}
+	_onClosed() {
+		if (this._watch !== void 0) this._timers.clearInterval(this._watch);
+		this._watch = void 0;
+	}
+	_watchHeartbeat() {
+		if (this._watch !== void 0) this._timers.clearInterval(this._watch);
+		this._watch = this._timers.setInterval(() => {
+			if (Date.now() - this._lastPing > 3 * this._heartbeatMs) this._finish(1006, "", false, true);
+		}, this._heartbeatMs);
+	}
+};
+/** Codes an endpoint may put in a close frame (RFC 6455 §7.4). */
+function isSendableCloseCode(code) {
+	if (!Number.isInteger(code)) return false;
+	if (code >= 3e3 && code <= 4999) return true;
+	return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006;
+}
+//#endregion
+//#region src/ws/upgrade.ts
+/**
+* The upgrade, as an HTTP exchange: a `GET` with `Upgrade: websocket` goes to
+* an ordinary `(Request) => Response` handler, and a `101` answer carrying a
+* server socket means accepted. Anything else is a refusal, with its status.
+*
+* FORBIDDEN HEADERS. A browser drops `Upgrade`, `Connection` and every
+* `Sec-*` header from a `new Request()`. The upgrade request therefore carries
+* its headers as an own `headers` property, a standalone `Headers` that keeps
+* them, so handler code reads `request.headers.get("upgrade")` as usual.
+*
+* NO 101 IN A `Response`. The constructor refuses statuses below 200, so the
+* response `upgradeWebSocket` returns reports 101 through an own `status`
+* property; the port that goes back to the caller is found with `takePort`.
+*/
+/** The request header carrying the client's version of the frame protocol. */
+const WS_VERSION_HEADER = "x-webrun-ws-version";
+/**
+* The `GET` a handler sees for `new WebSocket(url, protocols)`. A `ws:` or
+* `wss:` url is given as `http:` or `https:`, as a server sees it.
+*/
+function newWebSocketUpgradeRequest(url, { protocols = [], headers } = {}) {
+	const httpUrl = new URL(`${url}`);
+	if (httpUrl.protocol === "ws:") httpUrl.protocol = "http:";
+	else if (httpUrl.protocol === "wss:") httpUrl.protocol = "https:";
+	const all = new Headers(headers);
+	all.set("upgrade", "websocket");
+	all.set("connection", "Upgrade");
+	all.set("sec-websocket-version", "13");
+	if (!all.has("sec-websocket-key")) all.set("sec-websocket-key", randomKey());
+	if (protocols.length > 0) all.set("sec-websocket-protocol", protocols.join(", "));
+	if (!all.has("x-webrun-ws-version")) all.set(WS_VERSION_HEADER, `2`);
+	return withHeaders(new Request(httpUrl, {
+		method: "GET",
+		headers: all
+	}), all);
+}
+/**
+* Re-attaches `headers` to `request` as its own `headers` property, keeping
+* the forbidden ones a browser dropped. Returns `request`.
+*/
+function withHeaders(request, headers) {
+	Object.defineProperty(request, "headers", {
+		value: headers,
+		configurable: true
+	});
+	return request;
+}
+/** Whether `request` asks for a WebSocket. */
+function isWebSocketUpgrade(request) {
+	return request.headers.get("upgrade")?.toLowerCase() === "websocket";
+}
+/** The subprotocols `request` asks for, in order of preference. */
+function requestedProtocols(request) {
+	const header = request.headers.get("sec-websocket-protocol");
+	if (!header) return [];
+	return header.split(",").map((protocol) => protocol.trim()).filter((protocol) => protocol !== "");
+}
+/**
+* Where a response from `upgradeWebSocket` keeps its port. A registered
+* symbol, not a module-level `WeakMap`: the handler and the host that takes
+* the port often run different bundles of this package (a page's adapter from
+* `dist/sw.js`, its handler code importing `dist/worker.js`), and each bundle
+* has its own copy of every module.
+*/
+const UPGRADE = Symbol.for("webrun-http-browser:websocket-upgrade");
+/**
+* Accepts a WebSocket upgrade in a handler:
+*
+* ```ts
+* if (isWebSocketUpgrade(request)) {
+*   const { socket, response } = upgradeWebSocket(request, { protocol: "v1" });
+*   socket.accept();
+*   socket.addEventListener("message", (event) => socket.send(event.data));
+*   return response;
+* }
+* ```
+*
+* The host takes the client's port from the response with `takePort` and
+* hands it to the caller.
+*/
+function upgradeWebSocket(request, options = {}) {
+	const protocol = options.protocol ?? "";
+	const channel = new MessageChannel();
+	const socket = new ServerWebSocket(channel.port1, {
+		...options,
+		url: request.url,
+		protocol
+	});
+	const response = new Response(null, {
+		status: 200,
+		headers: protocol ? { "sec-websocket-protocol": protocol } : {}
+	});
+	Object.defineProperties(response, {
+		status: {
+			value: 101,
+			configurable: true
+		},
+		statusText: {
+			value: "Switching Protocols",
+			configurable: true
+		},
+		webSocket: {
+			value: socket,
+			configurable: true
+		},
+		[UPGRADE]: {
+			value: {
+				port: channel.port2,
+				protocol
+			},
+			configurable: true,
+			writable: true
+		}
+	});
+	return {
+		socket,
+		response
+	};
+}
+/**
+* The port to hand to the caller, for a response from `upgradeWebSocket`.
+* Taken once: a second call returns `undefined`.
+*/
+function takePort(response) {
+	return takeUpgrade(response)?.port;
+}
+/** `takePort`, with the subprotocol the server picked. */
+function takeUpgrade(response) {
+	const holder = response;
+	const upgrade = holder[UPGRADE];
+	if (upgrade) holder[UPGRADE] = void 0;
+	return upgrade;
+}
+/**
+* Runs an upgrade through `handler`, as a host does when a caller asks for a
+* socket: builds the upgrade request, calls the handler, and either takes the
+* port of a `101` or reports the refusal. A subprotocol the caller did not ask
+* for is a refusal, as in the standard.
+*/
+async function serveWebSocketUpgrade(handler, { url, protocols = [], headers }) {
+	let response;
+	try {
+		response = await handler(newWebSocketUpgradeRequest(url, {
+			protocols,
+			headers
+		}));
+	} catch (error) {
+		return {
+			ok: false,
+			status: 500,
+			message: errorMessage(error)
+		};
+	}
+	const upgrade = takeUpgrade(response);
+	if (!upgrade || response.status !== 101) {
+		upgrade?.port.close();
+		try {
+			await response.body?.cancel();
+		} catch {}
+		return {
+			ok: false,
+			status: response.status,
+			message: `The server refused the upgrade: ${response.status} ${response.statusText}`.trim()
+		};
+	}
+	if (upgrade.protocol !== "" && !protocols.includes(upgrade.protocol)) {
+		upgrade.port.close();
+		return {
+			ok: false,
+			status: 400,
+			message: `The server picked the subprotocol '${upgrade.protocol}', which was not requested.`
+		};
+	}
+	return {
+		ok: true,
+		port: upgrade.port,
+		protocol: upgrade.protocol
+	};
+}
+function randomKey() {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	return btoa(String.fromCharCode(...bytes));
+}
+//#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 empty = {
+		url: str,
+		key: "",
+		baseUrl: "",
+		path: ""
+	};
+	const hashIdx = str.indexOf("#");
+	const queryIdx = str.indexOf("?");
+	let strippedEnd = str.length;
+	if (hashIdx >= 0) strippedEnd = Math.min(strippedEnd, hashIdx);
+	if (queryIdx >= 0) strippedEnd = Math.min(strippedEnd, queryIdx);
+	const stripped = str.slice(0, strippedEnd);
+	let prefixEnd = 0;
+	const schemeMatch = stripped.match(/^[a-zA-Z][a-zA-Z0-9+\-.]*:\/\//);
+	if (schemeMatch) {
+		prefixEnd = schemeMatch[0].length;
+		const slashIdx = stripped.indexOf("/", prefixEnd);
+		if (slashIdx >= 0) prefixEnd = slashIdx;
+		else return empty;
+	} else if (stripped.startsWith("//")) {
+		prefixEnd = 2;
+		const slashIdx = stripped.indexOf("/", prefixEnd);
+		if (slashIdx >= 0) prefixEnd = slashIdx;
+		else return empty;
+	}
+	const prefix = stripped.slice(0, prefixEnd);
+	const pathPart = stripped.slice(prefixEnd);
+	let keyStart;
+	let rooted = false;
+	if (prefix === "") {
+		if (pathPart.startsWith(`/${separator}`)) {
+			rooted = true;
+			keyStart = separator.length + 1;
+		} else if (pathPart.startsWith(separator)) keyStart = separator.length;
+		else return empty;
+	} else {
+		if (!pathPart.startsWith(`/${separator}`)) return empty;
+		keyStart = separator.length + 1;
+	}
+	const rest = pathPart.slice(keyStart);
+	const slash = rest.indexOf("/");
+	const key = slash < 0 ? rest : rest.slice(0, slash);
+	if (key === "") return empty;
+	return {
+		url: str,
+		key,
+		baseUrl: `${prefix === "" ? rooted ? "/" : "" : `${prefix}/`}${separator}${key}${slash < 0 ? "" : "/"}`,
+		path: slash < 0 ? "" : rest.slice(slash + 1)
+	};
+}
+//#endregion
+//#region src/relay/index.ts
+/**
+* The URL of this module, kept in a variable on purpose. Bundlers (Vite
+* among them) rewrite every literal `new URL("<path>", import.meta.url)` into
+* an emitted asset at build time, before tree-shaking — so the defaults below
+* made every Vite consumer of this entry emit a dead copy of the package's
+* own `dist/index.js` (`"../"` resolves to the package, hence to its `main`).
+* Resolving against a variable is the same URL at run time and invisible to
+* that transform.
+*/
+const moduleUrl = import.meta.url;
+/**
+* Returns a MessagePort that transparently bridges messages to/from the
+* page's ServiceWorker: the one controlling the page, or — when the page is
+* not controlled (a hard reload, or a page Firefox left uncontrolled) — the
+* active worker of `registration`, which answers messages all the same.
+*/
+function newServiceWorkerPort(registration) {
+	const channel = new MessageChannel();
+	channel.port1.onmessage = (event) => {
+		(navigator.serviceWorker.controller ?? registration?.active)?.postMessage(event.data, [...event.ports]);
+	};
+	navigator.serviceWorker.addEventListener("message", (event) => {
+		channel.port1.postMessage(event.data, [...event.ports]);
+	});
+	return channel.port2;
+}
+/**
+* Registers a ServiceWorker and resolves with it once it is activated: the
+* worker controlling the page, or the registration's active worker when the
+* page is not controlled. Messaging works either way, which is all the relay
+* needs; nothing here waits for control, because an uncontrolled page (hard
+* reload; Firefox) may never get it. Rejects with a
+* `ServiceWorkerControlError` if activation takes longer than `timeout`.
+*/
+async function initServiceWorker(options) {
+	return (await registerServiceWorker(options)).worker;
+}
+async function registerServiceWorker({ swUrl, scopeUrl, type, timeout = DEFAULT_SERVICE_WORKER_TIMEOUT }) {
+	const registration = await navigator.serviceWorker.register(swUrl, {
+		type,
+		scope: scopeUrl
+	});
+	const active = await awaitActiveServiceWorker(registration, { timeout });
+	return {
+		registration,
+		worker: navigator.serviceWorker.controller ?? active
+	};
+}
+/**
+* Serves a service's side of one `CONNECT`: an HTTP link on `callPort`, or a
+* WebSocket upgrade run through `handler`.
+*/
+async function answerConnect(handler, data, callPort, options = {}) {
+	const params = data ?? {};
+	if (params.type === "ws") {
+		callPort?.close();
+		const { url, protocols = [], headers } = params;
+		const result = await serveWebSocketUpgrade(handler, {
+			url,
+			protocols,
+			headers
+		});
+		if (!result.ok) throw new Error(result.message);
+		return withTransfer({
+			port: result.port,
+			protocol: result.protocol
+		}, [result.port]);
+	}
+	if (!callPort) throw new Error("A CONNECT for HTTP carries a port");
+	if (params.wire === "webrun-http-link/2") {
+		await serveHttpLink(callPort, handler, options);
+		return {
+			accepted: true,
+			wire: HTTP_LINK_PROTOCOL
+		};
+	}
+	handleHttpRequests(callPort, handler);
+	return true;
+}
+/**
+* Registers `handler` as the server for the given service `key` on the relay:
+* it answers HTTP requests and WebSocket upgrades. Returns a function that
+* unregisters the service; its promise settles once the relay acknowledged.
+*/
+async function initHttpService(handler, { key, path, port, streamTimeout }) {
+	return await registerConnectionsHandler({
+		key,
+		path,
+		communicationPort: port,
+		handler: (_event, data, callPort) => answerConnect(handler, data, callPort, { streamTimeout })
+	});
+}
+/**
+* Sends a `Request` to the service registered under `key` on the relay and
+* resolves with the corresponding `Response`, whose body streams with
+* backpressure.
+*/
+async function callHttpService(request, { key, port, streamTimeout }) {
+	const channel = new MessageChannel();
+	const reply = await callChannel(port, "CONNECT", {
+		key,
+		type: "http",
+		wire: HTTP_LINK_PROTOCOL
+	}, channel.port2);
+	if (!reply) {
+		channel.port1.close();
+		throw new Error(`No service with key "${key}"`);
+	}
+	return await sendOverConnection(channel.port1, reply, request, { streamTimeout });
+}
+/**
+* Sends `request` on a port a service accepted with `reply`: over an HTTP link
+* when the service speaks `HTTP_LINK_PROTOCOL`, over version 1's transport
+* when it answered `true`. The link is closed once the response is done.
+*/
+async function sendOverConnection(port, reply, request, options = {}) {
+	if (reply === true) return await sendHttpRequest(port, request);
+	const link = await connectHttpLink(port, options);
+	try {
+		const response = await link.send(request);
+		link.whenIdle().then(() => link.close());
+		return response;
+	} catch (error) {
+		await link.close();
+		throw error;
+	}
+}
+/**
+* Opens the transport of a socket to the service registered under `key` on
+* the relay: the service runs the upgrade through its handler, and the
+* socket's port comes back through the relay. After that, the socket runs
+* between the caller and the service directly.
+*/
+async function callWebSocketService(url, protocols, { key, port, timeout = 15e3 }) {
+	const httpUrl = new URL(`${url}`, globalThis.location?.href);
+	if (httpUrl.protocol === "ws:") httpUrl.protocol = "http:";
+	else if (httpUrl.protocol === "wss:") httpUrl.protocol = "https:";
+	const channel = new MessageChannel();
+	try {
+		const connection = await callChannelWithin(timeout, port, "CONNECT", {
+			type: "ws",
+			key,
+			url: `${httpUrl}`,
+			protocols
+		}, channel.port2);
+		if (!(connection?.port instanceof MessagePort)) throw new Error(`The service "${key}" does not accept WebSockets (an older version?)`);
+		return {
+			port: connection.port,
+			protocol: connection.protocol ?? ""
+		};
+	} finally {
+		channel.port1.close();
+	}
+}
+/**
+* A WHATWG `WebSocket` class whose sockets reach the service registered under
+* `key` on the relay.
+*/
+function relayWebSocketClass(service, options) {
+	return createWebSocketClass((url, protocols) => callWebSocketService(url, protocols, service), options);
+}
+/**
+* Returns a `window.onmessage` handler for use inside the relay iframe:
+* it accepts a CONNECT message, starts the relay ServiceWorker, and bridges
+* the parent's MessagePort with the SW. If the worker cannot be started, every
+* call the parent makes on that port is answered with the error, so the
+* parent's `initHttpService` / `callHttpService` reject instead of waiting.
+*/
+function getRelayWindowMessageHandler({ swUrl = `${new URL("./relay-sw.js", moduleUrl)}`, scopeUrl = `${new URL("./", moduleUrl)}`, timeout } = {}) {
+	let externalPort;
+	return async (ev) => {
 		if (ev.data?.type !== "CONNECT") return;
 		const newExternalPort = ev.ports?.[0];
 		if (!newExternalPort) return;
@@ -2804,141 +4817,1769 @@ function getRelayWindowMessageHandler({ swUrl = `${new URL("./index-sw.js", modu
 			newExternalPort.close();
 			return;
 		}
-		externalPort = newExternalPort;
-		let registration;
+		externalPort = newExternalPort;
+		let registration;
+		try {
+			({registration} = await registerServiceWorker({
+				swUrl,
+				scopeUrl,
+				timeout
+			}));
+		} catch (error) {
+			const serialized = serializeError(error);
+			externalPort.onmessage = (event) => event.ports[0]?.postMessage({ error: serialized });
+			throw error;
+		}
+		const serviceWorkerPort = newServiceWorkerPort(registration);
+		serviceWorkerPort.onmessage = (event) => {
+			externalPort?.postMessage(event.data, [...event.ports]);
+		};
+		externalPort.onmessage = (event) => {
+			serviceWorkerPort.postMessage(event.data, [...event.ports]);
+		};
+	};
+}
+/**
+* Embeds a hidden relay iframe, establishes a MessageChannel with it, and
+* returns the port to be used with `initHttpService` / `callHttpService`.
+*/
+async function newRemoteRelayChannel({ baseUrl = new URL("../public-relay/", moduleUrl), url = new URL("relay.html", baseUrl), container = document.body } = {}) {
+	const messageChannel = new MessageChannel();
+	const { iframe, promise } = newIFrame(url);
+	Object.assign(iframe.style, {
+		position: "fixed",
+		width: "1px",
+		height: "1px",
+		top: "-1000px",
+		left: "-1000px",
+		display: "block",
+		opacity: "0",
+		border: "none",
+		outline: "none"
+	});
+	container.appendChild(iframe);
+	promise.then(() => {
+		iframe.contentWindow?.postMessage({ type: "CONNECT" }, "*", [messageChannel.port1]);
+	});
+	return {
+		baseUrl,
+		port: messageChannel.port2,
+		close: () => {
+			iframe.parentElement?.removeChild(iframe);
+			messageChannel.port1.close();
+			messageChannel.port2.close();
+		}
+	};
+	function newIFrame(src) {
+		const iframe = document.createElement("iframe");
+		iframe.src = `${src}`;
+		Object.assign(iframe.style, {
+			padding: "0",
+			margin: "0",
+			border: "none",
+			outline: "none",
+			width: "100%",
+			height: "100%"
+		});
+		return {
+			iframe,
+			promise: new Promise((resolve, reject) => {
+				iframe.onerror = () => reject(/* @__PURE__ */ new Error(`Failed to load ${src}`));
+				iframe.onload = () => resolve(iframe);
+			})
+		};
+	}
+}
+async function initializeConnection({ key, communicationPort, ...options }) {
+	const channel = new MessageChannel();
+	if (!await callChannel(communicationPort, "CONNECT", {
+		key,
+		...options
+	}, channel.port2)) {
+		channel.port1.close();
+		channel.port2.close();
+		return null;
+	}
+	return channel.port1;
+}
+/**
+* Registers `key` on the relay and answers its `CONNECT`s with `handler`.
+* Resolves with a function that unregisters it. That function's promise
+* settles once the relay acknowledged the `UNREGISTER`, so a caller can stop
+* its services and only then close the connection: closing first tore the
+* ports down before the message landed, and left the mount behind.
+*/
+async function registerConnectionsHandler({ key, path, handler, communicationPort }) {
+	await callChannel(communicationPort, "REGISTER", path == null ? { key } : {
+		key,
+		path
+	});
+	const stopAnswering = handleKeyedChannelCalls(communicationPort, "CONNECT", key, async (event, data, port) => await handler(event, data, port));
+	let stopped;
+	return () => {
+		stopped ??= (async () => {
+			try {
+				await callChannel(communicationPort, "UNREGISTER", { key });
+			} catch (error) {
+				console.warn(`[relay] UNREGISTER of "${key}" failed`, error);
+			} finally {
+				stopAnswering();
+			}
+		})();
+		return stopped;
+	};
+}
+/**
+* `handleChannelCalls`, but only for calls whose `params.key` is `key`.
+*
+* ONE CONNECTION CARRIES SEVERAL SERVICES — an app at `/` and a mesh gateway
+* at `/peers/` over one relay iframe is the shape mounts exist for. Plain
+* `handleChannelCalls` cannot do that: every listener it has for a call type
+* runs on every message, and each is handed the SAME reply port and the SAME
+* transferred stream port. Two services then both serve the one channel the
+* worker is reading, and its response comes back with both bodies in it.
+*
+* WHY NOT A FILTER INSIDE THE HANDLER. Returning `false` for a foreign key
+* does not help: `handleChannelCalls` still replies, `callChannel` resolves on
+* the FIRST reply it receives, and the loser's `false` reaches the worker as
+* "the client refused" — a 403, non-deterministically. A service that is not
+* the addressee must stay SILENT and leave the transferred port untouched.
+*
+* Local to this module on purpose. `handleChannelCalls` is also used where a
+* call carries no key (REGISTER/UNREGISTER, and the worker's own CONNECT in
+* `index-sw.ts`, which is the other direction), so its semantics must not
+* change.
+*/
+function handleKeyedChannelCalls(target, callType, key, handler) {
+	const listener = async (event) => {
+		const data = event.data;
+		if (!data || data.type !== callType) return;
+		if (data.params?.key !== key) return;
+		const [port, ...transfers] = event.ports ?? [];
+		const response = {};
+		let transfer = [];
+		try {
+			const result = await handler(event, data.params, ...transfers);
+			({value: response.result, transfer} = unwrapTransfer(result));
+		} catch (error) {
+			response.error = serializeError(error);
+		}
+		port?.postMessage(response, transfer);
+	};
+	target.addEventListener("message", listener);
+	target.start?.();
+	return () => target.removeEventListener("message", listener);
+}
+//#endregion
+//#region src/sw/handler-endpoint.ts
+/** The message calls through a lost ServiceWorker fail with. */
+const ROUTER_LOST_MESSAGE = "The ServiceWorker was lost while this call was in flight";
+/**
+* The handler's end of its links to the ServiceWorker, the same in a page and
+* in a Dedicated Worker.
+*
+* - Serves `handler` on each link's `down` port, and answers WebSocket
+*   upgrades arriving on its `ctl` port by running them through `handler`.
+* - Sends requests through the router on `up` (`fetch`) and opens sockets to
+*   other handlers over `ctl` (`connectWebSocket`).
+* - Watches the ServiceWorker's router lock. When the ServiceWorker dies, the
+*   links made for it are dropped: calls in flight on them fail with
+*   `LinkLostError` ("may or may not have been applied") instead of hanging,
+*   and new calls wait for a link, asking for one (`requestRelink`) every
+*   `relinkRetryMs` until it comes.
+* - While calls are in flight, calls `keepAlive` every `keepAliveMs`: port
+*   messages are not events, so without it the browser may stop the
+*   ServiceWorker in the middle of a long call.
+*/
+var HandlerEndpoint = class {
+	handler;
+	options;
+	_links = /* @__PURE__ */ new Set();
+	_waiters = [];
+	_sockets = new PortRendezvous("o");
+	_keepAliveTimer;
+	_closed = false;
+	constructor(handler, options = {}) {
+		this.handler = handler;
+		this.options = options;
+	}
+	/** Whether any link is live. */
+	get linked() {
+		return this._links.size > 0;
+	}
+	/** Installs a fresh link made for the router holding `routerLock`. */
+	async link(key, ports, routerLock) {
+		if (this._closed) {
+			for (const port of Object.values(ports)) port?.close();
+			return;
+		}
+		const closeDown = await serveHttpLink(ports.down, this.handler, this.options);
+		const up = ports.up ? await connectHttpLink(ports.up, this.options) : void 0;
+		const link = {
+			key,
+			routerLock,
+			ctl: ports.ctl,
+			up,
+			closeDown,
+			stopWatch: () => {}
+		};
+		if (ports.ctl) ports.ctl.onmessage = (event) => this._onControl(link, event.data);
+		if (routerLock) link.stopWatch = watchLock(routerLock, () => this._routerLost(routerLock));
+		for (const old of [...this._links]) {
+			if (old.key !== key) continue;
+			if (old.routerLock !== routerLock) this._drop(old, new LinkLostError(ROUTER_LOST_MESSAGE));
+			else if (!old.superseded) {
+				old.superseded = true;
+				setTimeout(() => void this._drop(old), this.options.supersededLinkMs ?? 3e4);
+			}
+		}
+		this._links.add(link);
+		for (const wake of this._waiters.splice(0)) wake();
+	}
+	/** Drops the links attached under `key` (all of them without a key). */
+	async unlink(key, reason) {
+		const dropped = [...this._links].filter((link) => key === void 0 || link.key === key);
+		await Promise.all(dropped.map((link) => this._drop(link, reason)));
+	}
+	/** The routers this endpoint has live links for. */
+	routerLocks() {
+		return new Set([...this._links].map((link) => link.routerLock));
+	}
+	/**
+	* Sends `request` through the ServiceWorker's router, as if the browser had
+	* fetched it: it reaches the handler its url routes to.
+	*/
+	async fetch(request) {
+		const link = await this._linkWith("up");
+		this._startKeepAlive();
+		return await link.up.send(request);
+	}
+	/** Opens a socket to the handler `url` routes to, through the ServiceWorker. */
+	async connectWebSocket(url, protocols = []) {
+		const link = await this._linkWith("ctl");
+		const id = this._sockets.newId();
+		const answer = this._sockets.wait(id, this.options.wsConnectTimeoutMs ?? 15e3, `the socket request for ${url}`);
+		link.ctl?.postMessage({
+			t: "ws-open",
+			id,
+			url,
+			protocols
+		});
+		return await answer;
+	}
+	async close() {
+		this._closed = true;
+		if (this._keepAliveTimer) clearInterval(this._keepAliveTimer);
+		await this.unlink(void 0, new LinkLostError("The handler was closed"));
+		for (const wake of this._waiters.splice(0)) wake();
+	}
+	async _drop(link, reason) {
+		if (!this._links.delete(link)) return;
+		link.stopWatch();
+		await link.up?.close(reason);
+		try {
+			await link.closeDown();
+		} catch {}
+		if (link.ctl) {
+			link.ctl.onmessage = null;
+			link.ctl.close();
+		}
+	}
+	_routerLost(routerLock) {
+		const reason = new LinkLostError(ROUTER_LOST_MESSAGE);
+		for (const link of [...this._links]) if (link.routerLock === routerLock) this._drop(link, reason);
+		this._sockets.failAll(reason);
+	}
+	/** A live link with `port`, waiting (and asking) for one when there is none. */
+	async _linkWith(port) {
+		const find = () => [...this._links].filter((link) => !link.superseded).reverse().find((link) => port === "up" ? link.up && !link.up.closed : link.ctl);
+		const found = find();
+		if (found) return found;
+		const retryMs = this.options.relinkRetryMs ?? 2e3;
+		const deadline = Date.now() + (this.options.relinkTimeoutMs ?? 3e4);
+		while (!this._closed) {
+			this.options.requestRelink?.();
+			await new Promise((resolve) => {
+				const timer = setTimeout(resolve, Math.max(0, Math.min(retryMs, deadline - Date.now())));
+				this._waiters.push(() => {
+					clearTimeout(timer);
+					resolve();
+				});
+			});
+			const link = find();
+			if (link) return link;
+			if (Date.now() >= deadline) break;
+		}
+		throw new LinkLostError("No link to the ServiceWorker could be made for this call");
+	}
+	_startKeepAlive() {
+		if (this._keepAliveTimer || !this.options.keepAlive) return;
+		this._keepAliveTimer = setInterval(() => {
+			if ([...this._links].reduce((sum, link) => sum + (link.up?.inflight ?? 0), 0) === 0) {
+				clearInterval(this._keepAliveTimer);
+				this._keepAliveTimer = void 0;
+				return;
+			}
+			this.options.keepAlive?.();
+		}, this.options.keepAliveMs ?? 2e4);
+	}
+	_onControl(link, message) {
+		if (!message || typeof message !== "object") return;
+		switch (message.t) {
+			case "ws-connect":
+				this._acceptSocket(link, message);
+				return;
+			case "ws-opened":
+				if (!this._sockets.settle(message.id, {
+					port: message.port,
+					protocol: message.protocol
+				})) message.port.close();
+				return;
+			case "ws-failed":
+				this._sockets.fail(message.id, new Error(message.message));
+				return;
+		}
+	}
+	async _acceptSocket(link, { id, url, protocols, headers }) {
+		const ctl = link.ctl;
+		if (!ctl) return;
+		try {
+			const result = await serveWebSocketUpgrade(this.handler, {
+				url,
+				protocols,
+				headers
+			});
+			if (result.ok) ctl.postMessage({
+				t: "ws-accept",
+				id,
+				protocol: result.protocol,
+				port: result.port
+			}, [result.port]);
+			else ctl.postMessage({
+				t: "ws-refuse",
+				id,
+				status: result.status,
+				message: result.message
+			});
+		} catch (error) {
+			ctl.postMessage({
+				t: "ws-refuse",
+				id,
+				status: 500,
+				message: errorMessage(error)
+			});
+		}
+	}
+};
+//#endregion
+//#region src/sw/handler-table.ts
+/**
+* The default route: the handler with the fewest requests in flight, the
+* oldest on a tie. With one handler per key — one tab — that is the first
+* live handler of the key, as before routing was pluggable.
+*/
+const leastInflightRoute = (_request, _key, handlers) => {
+	let best;
+	for (const handler of handlers) if (best === void 0 || handler.inflight < best.inflight || handler.inflight === best.inflight && handler.attachedAt < best.attachedAt) best = handler;
+	return best;
+};
+var HandlerTable = class {
+	_entries = /* @__PURE__ */ new Map();
+	_waiters = [];
+	/** Adds `entry`. Returns the entry it replaces (same key and id), if any. */
+	add(entry) {
+		let slots = this._entries.get(entry.key);
+		if (!slots) {
+			slots = /* @__PURE__ */ new Map();
+			this._entries.set(entry.key, slots);
+		}
+		const replaced = slots.get(entry.id);
+		slots.set(entry.id, entry);
+		if (!entry.draining) this._waiters = this._waiters.filter(({ key, resolve }) => {
+			if (key !== entry.key) return true;
+			resolve(true);
+			return false;
+		});
+		return replaced;
+	}
+	/** Removes `entry` if it is still the one in its slot. */
+	remove(entry) {
+		const slots = this._entries.get(entry.key);
+		if (slots?.get(entry.id) !== entry) return false;
+		slots.delete(entry.id);
+		if (slots.size === 0) this._entries.delete(entry.key);
+		return true;
+	}
+	get(key, id) {
+		return this._entries.get(key)?.get(id);
+	}
+	/** Every entry of `key`, draining or not. */
+	all(key) {
+		return [...this._entries.get(key)?.values() ?? []];
+	}
+	/** The entries of `key` that take new requests. */
+	live(key) {
+		return this.all(key).filter((entry) => !entry.draining);
+	}
+	entries() {
+		return [...this._entries.values()].flatMap((slots) => [...slots.values()]);
+	}
+	get size() {
+		let size = 0;
+		for (const slots of this._entries.values()) size += slots.size;
+		return size;
+	}
+	/**
+	* Resolves `true` once a live entry for `key` is added (at once if there is
+	* one, unless `next`), `false` after `ms`.
+	*/
+	waitFor(key, ms, next = false) {
+		if (!next && this.live(key).length > 0) return Promise.resolve(true);
+		return new Promise((resolve) => {
+			const waiter = {
+				key,
+				resolve: (found) => {
+					clearTimeout(timer);
+					resolve(found);
+				}
+			};
+			const timer = setTimeout(() => {
+				this._waiters = this._waiters.filter((w) => w !== waiter);
+				resolve(false);
+			}, ms);
+			this._waiters.push(waiter);
+		});
+	}
+};
+//#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/sw/protocol.ts
+/**
+* The messages between pages, Dedicated Workers and the same-origin
+* ServiceWorker. Internal: the shapes may change between versions, which is
+* why every hand-shake carries `HTTP_LINK_PROTOCOL`.
+*
+* THREE PORTS PER HANDLER LINK. A page makes the channels and hands one end of
+* each to the handler (itself, or a worker) and the other to the
+* ServiceWorker; after that it carries nothing:
+*
+* - `down`: ServiceWorker → handler, the requests the handler serves;
+* - `ctl`: a raw port next to them, for what HTTP over a stream cannot carry,
+*   transferred `MessagePort`s (WebSocket hand-over);
+* - `up` (workers only): handler → ServiceWorker, the requests the handler
+*   sends through the router (to other handlers).
+*/
+/** Page → ServiceWorker: attach a handler link. The name is the one version 1 used. */
+const ATTACH_CALL = "UPDATE_COMMUNICATION_PORT";
+/** Page → ServiceWorker: remove a handler link now. */
+const DETACH_CALL = "webrun-http:detach";
+/** Page → ServiceWorker: stop routing to a link, let its requests finish, then remove it. */
+const DRAIN_CALL = "webrun-http:drain";
+/** Page → ServiceWorker: open a WebSocket to a handler. */
+const WS_CONNECT_CALL = "webrun-http:ws-connect";
+/** ServiceWorker → pages: attach your links again (the ServiceWorker restarted). */
+const NEED_LINKS_CALL = "webrun-http:need-links";
+/**
+* Page → ServiceWorker, plain messages (no reply). A message to the
+* ServiceWorker object is an event: it starts a stopped worker and resets its
+* idle timer. Port messages do neither.
+*/
+const WAKE_MESSAGE = "webrun-http:wake";
+const KEEPALIVE_MESSAGE = "webrun-http:keepalive";
+/** Page ↔ worker: what `attachWorker` and `serveHttpInWorker` exchange. */
+const WORKER_HELLO = "webrun-http:worker-hello";
+//#endregion
+//#region src/sw/http-sw-dispatcher.ts
+/** One attached handler link, as the ServiceWorker holds it. */
+var HandlerEntry = class {
+	key;
+	id;
+	owner;
+	meta;
+	link;
+	ctl;
+	clientId;
+	ownerLock;
+	draining = false;
+	attachedAt = Date.now();
+	sockets;
+	stopWatch = () => {};
+	closeUp;
+	constructor(key, id, owner, meta, link, ctl, clientId, ownerLock) {
+		this.key = key;
+		this.id = id;
+		this.owner = owner;
+		this.meta = meta;
+		this.link = link;
+		this.ctl = ctl;
+		this.clientId = clientId;
+		this.ownerLock = ownerLock;
+		this.sockets = new PortRendezvous(`s:${id}`);
+	}
+	get inflight() {
+		return this.link.inflight;
+	}
+};
+/** The reason requests fail with when their handler dies under them. */
+const HANDLER_LOST_MESSAGE = "The handler was lost while this request was in flight";
+const TIMED_OUT = Symbol("timed-out");
+/**
+* The same-origin ServiceWorker: routes `fetch` events under its scope to
+* handler links that pages attach — handlers in the pages themselves
+* (`SwHttpAdapter.register`) or in Dedicated Workers
+* (`SwHttpAdapter.attachWorker` + `serveHttpInWorker`).
+*
+* A url `<scope>/<key>/...` belongs to the handlers of `key`. Of those, the
+* `route` option picks one per request. Requests and responses stream with
+* backpressure in both directions, and an aborted fetch reaches the handler
+* as a cancellation (webrun-rpc + webrun-http-streams).
+*
+* Urls of keys this worker never served go to the network untouched: the
+* worker does not call `respondWith` for them.
+*
+* RESTARTS. The browser stops an idle ServiceWorker, and every port it held
+* dies with it. Nothing is persisted but the set of keys ever served: the
+* first request after a restart asks every window to attach its links again
+* (`NEED_LINKS`) and waits for them.
+*
+* LIVENESS. Each handler holds an owner lock; when it is granted to this
+* worker, the handler is gone and its requests in flight fail at once (502).
+* This worker holds a router lock that handlers watch the same way.
+*/
+var SwHttpDispatcher = class {
+	self;
+	log;
+	options;
+	table = new HandlerTable();
+	/**
+	* Keys that were served at some point on this worker (sticky, kept in
+	* IndexedDB). Lets a fetch tell "a site url whose handler is gone → 404"
+	* from "an unknown url under the scope → the network".
+	*/
+	claimedKeys = /* @__PURE__ */ new Set();
+	/** The Web Lock this worker holds while it lives; handlers watch it. */
+	routerLock;
+	_routerHeld = Promise.resolve();
+	_restored = Promise.resolve();
+	_restoreSettled = false;
+	_cleanup = [];
+	_livenessTimer;
+	_relinkRounds = /* @__PURE__ */ new Map();
+	/** Keys whose last handler was drained: until the time stored, requests wait for the next. */
+	_vacant = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.self = options.self;
+		this.log = options.log ?? (() => {});
+		if (locksAvailable()) this.routerLock = newLockName("webrun-http-router");
+	}
+	get scope() {
+		return `${new URL("./", this.self.location.href)}`;
+	}
+	/** The key `url` belongs to: its first path segment under the scope. */
+	keyOf(url) {
+		const href = `${url}`;
+		const scope = this.scope;
+		if (!href.startsWith(scope)) return void 0;
+		const key = href.substring(scope.length).replace(/[?#].*$/, "").split("/")[0];
+		return key ? decodeURIComponent(key) : void 0;
+	}
+	/** Whether `key` has ever been served on this worker. */
+	isClaimedKey(key) {
+		return this.claimedKeys.has(key);
+	}
+	/** Whether requests for `key` are this worker's to answer. */
+	serves(key) {
+		return this.claimedKeys.has(key) || this.table.all(key).length > 0;
+	}
+	start() {
+		const self = this.self;
+		if (this.routerLock) this._routerHeld = holdLock(this.routerLock).then(() => {});
+		this._restored = this._restoreClaimedKeys();
+		const latch = () => {
+			this._restoreSettled = true;
+		};
+		this._restored.then(latch, latch);
+		this._cleanup.push(handleClaimRequests(self), handleChannelCalls(self, ATTACH_CALL, (event, params, ...ports) => this._attach(event, params, ports)), handleChannelCalls(self, DETACH_CALL, (_event, params) => {
+			const entry = this._find(params);
+			if (!entry) return false;
+			this._close(entry, new LinkLostError("The handler was detached"));
+			return true;
+		}), handleChannelCalls(self, DRAIN_CALL, async (_event, params) => {
+			const entry = this._find(params);
+			if (!entry) return false;
+			this._vacant.set(entry.key, Date.now() + (this.options.attachTimeoutMs ?? 15e3));
+			await this._retire(entry, params.ms ?? this.options.handoverMs ?? 5e3);
+			return true;
+		}), handleChannelCalls(self, WS_CONNECT_CALL, async (event, params) => {
+			if (!this._isOwnClient(event)) throw new Error("Only this origin's pages may open sockets");
+			const { url, protocols } = params;
+			const connection = await this.connectWebSocket(url, protocols ?? []);
+			return withTransfer(connection, [connection.port]);
+		}));
+		const onMessage = (event) => {
+			const type = event.data?.type;
+			if (type === "webrun-http:wake") event.waitUntil(this._askForLinks());
+			else if (type === "webrun-http:keepalive") event.waitUntil(Promise.resolve());
+		};
+		self.addEventListener("message", onMessage);
+		this._cleanup.push(() => self.removeEventListener("message", onMessage));
+		const onInstall = (event) => {
+			this.log("Skip waiting on install.");
+			event.waitUntil(self.skipWaiting());
+		};
+		const onActivate = (event) => {
+			this.log("Claim control over all clients.");
+			event.waitUntil(self.clients.claim());
+		};
+		const onFetch = (event) => this._onFetch(event);
+		self.addEventListener("install", onInstall);
+		self.addEventListener("activate", onActivate);
+		self.addEventListener("fetch", onFetch);
+		this._cleanup.push(() => {
+			self.removeEventListener("install", onInstall);
+			self.removeEventListener("activate", onActivate);
+			self.removeEventListener("fetch", onFetch);
+		});
+	}
+	async stop() {
+		for (const cleanup of this._cleanup.splice(0)) cleanup();
+		if (this._livenessTimer) clearInterval(this._livenessTimer);
+		this._livenessTimer = void 0;
+		for (const entry of this.table.entries()) this._close(entry, new LinkLostError("The ServiceWorker dispatcher stopped"));
+	}
+	/**
+	* Answers `request` as a fetch under the scope would be: through the
+	* handler its key routes to. A url outside the scope, or of a key this
+	* worker never served, goes to the network.
+	*/
+	async dispatch(request) {
+		const key = this.keyOf(request.url);
+		if (key === void 0) return await fetch(request);
+		await this._restored.catch(() => {});
+		const entry = await this._acquire(request, key);
+		if (entry === TIMED_OUT) return new Response(null, {
+			status: 503,
+			statusText: "Service Unavailable (no handler attached in time)"
+		});
+		if (!entry) {
+			if (!this.serves(key)) return await fetch(request);
+			return new Response(null, {
+				status: 404,
+				statusText: "Not Found (no active handler)"
+			});
+		}
+		try {
+			return await entry.link.send(request);
+		} catch (error) {
+			this.log("[dispatch] failed", key, error);
+			return new Response(errorMessage(error), {
+				status: 502,
+				statusText: "Bad Gateway",
+				headers: { "content-type": "text/plain; charset=utf-8" }
+			});
+		}
+	}
+	/**
+	* Opens a socket to the handler `url` routes to: the handler accepts or
+	* refuses it like an HTTP upgrade, and the socket's port comes back. After
+	* that the socket runs between the caller and the handler directly; this
+	* worker is not on its data path.
+	*/
+	async connectWebSocket(url, protocols = [], headers) {
+		const request = newWebSocketUpgradeRequest(url, {
+			protocols,
+			headers
+		});
+		const key = this.keyOf(request.url);
+		if (key === void 0) throw new Error(`${url} is outside this ServiceWorker's scope`);
+		await this._restored.catch(() => {});
+		const entry = await this._acquire(request, key);
+		if (!entry || entry === TIMED_OUT) throw new Error(`No handler serves ${url}`);
+		if (!entry.ctl) throw new Error(`The handler of ${url} does not accept sockets`);
+		const id = entry.sockets.newId();
+		const answer = entry.sockets.wait(id, this.options.wsConnectTimeoutMs ?? 15e3, `the socket request for ${url}`);
+		entry.ctl.postMessage({
+			t: "ws-connect",
+			id,
+			url: request.url,
+			protocols,
+			headers
+		});
+		return await answer;
+	}
+	_onFetch(event) {
+		const request = event.request;
+		const key = this.keyOf(request.url);
+		if (key === void 0) return;
+		if (this._restoreSettled) {
+			if (this.serves(key)) event.respondWith(this.dispatch(request));
+			else if (request.mode === "navigate") event.respondWith(fetch(request));
+			return;
+		}
+		event.respondWith((async () => {
+			await this._restored.catch(() => {});
+			if (!this.serves(key)) return await fetch(request);
+			return await this.dispatch(request);
+		})());
+	}
+	async _attach(event, params, ports) {
+		const clientId = event.source?.id;
+		const [down, ...rest] = ports;
+		if (!down) throw new Error("An attach carries at least one port");
+		this.log("[attach]", clientId, params);
+		if (params.wire === void 0) {
+			const link = trackedLink((request) => sendHttpRequest(down, request), () => down.close());
+			const id = clientId ?? crypto.randomUUID();
+			this._add(new HandlerEntry(params.key, id, id, void 0, link, void 0, clientId, void 0));
+			return { ...params };
+		}
+		if (params.wire !== "webrun-http-link/2") {
+			for (const port of ports) port.close();
+			throw new Error(`This ServiceWorker speaks ${HTTP_LINK_PROTOCOL}, the page ${params.wire}. Reload the page so that both run the same version of @statewalker/webrun-http-browser.`);
+		}
+		const ctl = params.ctl ? rest.shift() : void 0;
+		const up = params.up ? rest.shift() : void 0;
+		const streamTimeout = this.options.streamTimeout;
+		const link = await connectHttpLink(down, { streamTimeout });
+		const entry = new HandlerEntry(params.key, params.id ?? clientId ?? crypto.randomUUID(), params.owner ?? crypto.randomUUID(), params.meta, link, ctl, clientId, params.ownerLock);
+		if (up) entry.closeUp = await serveHttpLink(up, (request) => this.dispatch(request), { streamTimeout });
+		if (ctl) ctl.onmessage = (message) => this._onControl(entry, message.data);
+		if (params.ownerLock) entry.stopWatch = watchLock(params.ownerLock, () => {
+			this.log("[owner lost]", entry.key, entry.id);
+			this._close(entry, new LinkLostError(HANDLER_LOST_MESSAGE));
+		});
+		this._add(entry);
+		await this._routerHeld;
+		return {
+			accepted: HTTP_LINK_PROTOCOL,
+			routerLock: this.routerLock
+		};
+	}
+	_add(entry) {
+		this._vacant.delete(entry.key);
+		const replaced = this.table.add(entry);
+		if (replaced && replaced !== entry) this._retire(replaced, this.options.handoverMs ?? 5e3, false);
+		this._claim(entry.key);
+		if (entry.ownerLock) this._watchLiveness();
+	}
+	/**
+	* The backup of the owner-lock watches: every `livenessCheckMs`, drops the
+	* handlers whose owner lock is no longer held. Runs only while some handler
+	* has an owner lock, and keeps nothing awake: a timer is not an event.
+	*/
+	_watchLiveness() {
+		const period = this.options.livenessCheckMs ?? 5e3;
+		if (this._livenessTimer || period <= 0) return;
+		this._livenessTimer = setInterval(async () => {
+			const watched = this.table.entries().filter((entry) => entry.ownerLock);
+			if (watched.length === 0) {
+				clearInterval(this._livenessTimer);
+				this._livenessTimer = void 0;
+				return;
+			}
+			const held = await heldLockNames();
+			if (!held) return;
+			for (const entry of watched) if (entry.ownerLock && !held.has(entry.ownerLock) && this.table.remove(entry)) {
+				this.log("[owner gone]", entry.key, entry.id);
+				this._close(entry, new LinkLostError(HANDLER_LOST_MESSAGE), false);
+			}
+		}, period);
+	}
+	/** The entry a drain or detach names, if its owner token still matches. */
+	_find({ key, id, owner }) {
+		const entry = this.table.get(key, id);
+		return entry && entry.owner === owner ? entry : void 0;
+	}
+	/**
+	* Stops routing to `entry`, lets its requests in flight run for up to `ms`,
+	* then closes it. Requests that arrive meanwhile wait for the next owner.
+	*/
+	async _retire(entry, ms, inTable = true) {
+		entry.draining = true;
+		let timer;
+		await Promise.race([entry.link.whenIdle(), new Promise((resolve) => {
+			timer = setTimeout(resolve, ms);
+		})]);
+		clearTimeout(timer);
+		this._close(entry, new LinkLostError("The handler was drained"), inTable);
+	}
+	_close(entry, reason, inTable = true) {
+		if (inTable) this.table.remove(entry);
+		entry.stopWatch();
+		entry.sockets.failAll(reason);
+		entry.link.close(reason);
+		entry.closeUp?.().catch(() => {});
+		if (entry.ctl) {
+			entry.ctl.onmessage = null;
+			entry.ctl.close();
+		}
+	}
+	/**
+	* The handler for `request`: picked by `route` among the live handlers of
+	* its key, waiting for one when there is none.
+	*/
+	async _acquire(request, key) {
+		const picked = await this._pick(request, key);
+		if (picked) return picked;
+		if (this.table.all(key).length > 0) return await this.table.waitFor(key, this.options.attachTimeoutMs ?? 15e3, this.table.live(key).length > 0) ? await this._pick(request, key) ?? TIMED_OUT : TIMED_OUT;
+		const vacantUntil = this._vacant.get(key) ?? 0;
+		if (vacantUntil > Date.now()) return await this.table.waitFor(key, vacantUntil - Date.now()) ? await this._pick(request, key) ?? TIMED_OUT : TIMED_OUT;
+		if (!this.serves(key)) return void 0;
+		await this._askForLinks(key);
+		return await this._pick(request, key);
+	}
+	async _pick(request, key) {
+		let live = this.table.live(key);
+		for (const entry of live) {
+			if (entry.ownerLock || !entry.clientId) continue;
+			if (!await this.self.clients.get(entry.clientId)) this._close(entry, new LinkLostError(HANDLER_LOST_MESSAGE));
+		}
+		live = this.table.live(key);
+		if (live.length === 0) return void 0;
+		return (this.options.route ?? leastInflightRoute)(request, key, live);
+	}
+	/**
+	* Asks every window to attach its links again, and waits until a handler
+	* for `key` is back, every window answered, or `relinkTimeoutMs` passed.
+	* At most one round per key every 10 s: a key whose tab is simply gone
+	* should not cost every request the wait.
+	*/
+	_askForLinks(key = "") {
+		const round = this._relinkRounds.get(key);
+		if (round && Date.now() - round.at < 1e4) return round.done;
+		const done = this._linkRound(key);
+		this._relinkRounds.set(key, {
+			at: Date.now(),
+			done
+		});
+		return done;
+	}
+	async _linkRound(key) {
+		const timeout = this.options.relinkTimeoutMs ?? 3e3;
+		const windows = await this.self.clients.matchAll({
+			type: "window",
+			includeUncontrolled: true
+		});
+		this.log("[need-links]", key, windows.length);
+		const params = { routerLock: this.routerLock };
+		const pending = new Set(windows);
+		const answered = Promise.allSettled(windows.map((client) => callChannel(client, NEED_LINKS_CALL, params).then(() => pending.delete(client))));
+		let timer;
+		const timedOut = new Promise((resolve) => {
+			timer = setTimeout(resolve, timeout);
+		});
+		await Promise.race([answered, timedOut]);
+		clearTimeout(timer);
+		for (const client of pending) this._askLegacyPage(client);
+	}
+	/** Asks a version-1 page for a fresh port, as version 1's worker did. */
+	_askLegacyPage(client) {
+		const channel = new MessageChannel();
+		callChannel(client, ATTACH_CALL, {}, channel.port2).then((info) => {
+			if (!info?.key || info.wire !== void 0) return;
+			const link = trackedLink((request) => sendHttpRequest(channel.port1, request), () => channel.port1.close());
+			this._add(new HandlerEntry(info.key, client.id, client.id, void 0, link, void 0, client.id, void 0));
+		}, () => channel.port1.close());
+	}
+	_onControl(entry, message) {
+		if (!message || typeof message !== "object") return;
+		switch (message.t) {
+			case "ws-accept":
+				if (!entry.sockets.settle(message.id, {
+					port: message.port,
+					protocol: message.protocol
+				})) message.port.close();
+				return;
+			case "ws-refuse":
+				entry.sockets.fail(message.id, new Error(message.message));
+				return;
+			case "ws-open":
+				this.connectWebSocket(message.url, message.protocols).then(({ port, protocol }) => entry.ctl?.postMessage({
+					t: "ws-opened",
+					id: message.id,
+					protocol,
+					port
+				}, [port]), (error) => entry.ctl?.postMessage({
+					t: "ws-failed",
+					id: message.id,
+					message: errorMessage(error)
+				}));
+				return;
+		}
+	}
+	_isOwnClient(event) {
+		const source = event.source;
+		if (!source?.url) return false;
+		try {
+			return new URL(source.url).origin === this.self.location.origin;
+		} catch {
+			return false;
+		}
+	}
+	async _claim(key) {
+		if (!key || this.claimedKeys.has(key)) return;
+		this.claimedKeys.add(key);
+		try {
+			await set("claimedKeys", [...this.claimedKeys].sort());
+		} catch (error) {
+			this.log("[claimedKeys] not stored", error);
+		}
+	}
+	async _restoreClaimedKeys() {
+		const stored = await get("claimedKeys") ?? [];
+		for (const key of stored) this.claimedKeys.add(key);
+	}
+};
+/**
+* Starts the same-origin dispatcher in a ServiceWorker. Returns a function
+* that stops it.
+*/
+function startHttpDispatcher(options) {
+	const dispatcher = new SwHttpDispatcher(options);
+	dispatcher.start();
+	return () => {
+		dispatcher.stop();
+	};
+}
+//#endregion
+//#region src/sw/worker-url.ts
+/**
+* Resolve a `serviceWorkerUrl` option the way a page would: relative to the
+* current document. Absolute urls pass through untouched. A url that cannot
+* be resolved is reported with the option name and the offending value,
+* because the raw `TypeError: Failed to construct 'URL': Invalid URL` says
+* neither.
+*/
+function resolveWorkerUrl(serviceWorkerUrl) {
+	const base = globalThis.location?.href;
+	try {
+		return new URL(serviceWorkerUrl, base);
+	} catch (error) {
+		throw new Error(`Invalid serviceWorkerUrl: ${JSON.stringify(serviceWorkerUrl)}` + (base ? ` (relative to ${base})` : " (no document to resolve it against)"), { cause: error });
+	}
+}
+//#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;
+	_registration;
+	_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;
+	}
+	/**
+	* The scope as a url on the worker's origin. Resolved against the worker's
+	* own url when one is given, not against this module's: a bundle that is
+	* not an ES module (an IIFE, Theia's frontend) has no `import.meta.url`, and
+	* `new URL(scope, undefined)` threw `Invalid URL` there. Only without a
+	* worker url does the module's location decide (its default `sw-worker.js`
+	* sits next to it).
+	*/
+	get rootUrl() {
+		const base = this.options.serviceWorkerUrl ? this.serviceWorkerUrl : import.meta.url;
+		return new URL(this.scope, base);
+	}
+	get serviceWorkerUrl() {
+		if (!this._serviceWorkerUrl) {
+			const url = this.options.serviceWorkerUrl ? resolveWorkerUrl(this.options.serviceWorkerUrl) : new URL("./sw-worker.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 };
+	}
+	/**
+	* Registers the worker and waits until it is activated and controls this
+	* page, then opens the port to it. The page must be controlled, because
+	* only a controlled page's `fetch()` reaches the worker. When the page
+	* loaded uncontrolled (a hard reload does that), the worker is asked to
+	* claim it. Rejects with a `ServiceWorkerControlError` when that fails or
+	* `timeout` passes (`reason` says which step); a later `start()` tries
+	* again.
+	*/
+	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 });
+			this._registration = registration;
+			const stopListening = handleChannelCalls(navigator.serviceWorker, "UPDATE_COMMUNICATION_PORT", async (_event, _params, port) => {
+				await this._setCommunicationPort(port);
+				return this._getRegistrationInfo();
+			});
+			register(stopListening);
+			const timeout = this.options.timeout ?? 3e4;
+			const deadline = Date.now() + timeout;
+			try {
+				this._serviceWorker = await awaitServiceWorkerControl(registration, {
+					timeout,
+					reloadIfUncontrolled: this.options.reloadIfUncontrolled
+				});
+				await withDeadline(deadline, this._updateCommunicationChannel(), () => new ServiceWorkerControlError("unresponsive", `ServiceWorker "${this._serviceWorker?.scriptURL}" controls this page but did not answer the UPDATE_COMMUNICATION_PORT handshake within ${timeout} ms. Check that the worker script runs this package's same-origin dispatcher (it importScripts \`sw-worker.js\`, or calls \`startHttpDispatcher\`).`));
+			} catch (error) {
+				stopListening();
+				this._cleanupRegistrations = void 0;
+				this._registration = void 0;
+				this._registrationPromise = void 0;
+				throw error;
+			}
+		})();
+		return this._registrationPromise;
+	}
+	async stop() {
+		this._cleanupRegistrations?.();
+		const registration = this._registration;
+		this._registration = void 0;
 		try {
-			({registration} = await registerServiceWorker({
-				swUrl,
-				scopeUrl,
-				timeout
-			}));
+			await registration?.unregister();
 		} catch (error) {
-			const serialized = serializeError(error);
-			externalPort.onmessage = (event) => event.ports[0]?.postMessage({ error: serialized });
-			throw error;
+			console.log("Service Worker unregistration failed: ", error);
 		}
-		const serviceWorkerPort = newServiceWorkerPort(registration);
-		serviceWorkerPort.onmessage = (event) => {
-			externalPort?.postMessage(event.data, [...event.ports]);
-		};
-		externalPort.onmessage = (event) => {
-			serviceWorkerPort.postMessage(event.data, [...event.ports]);
+	}
+};
+/**
+* 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() {
+		const stopClaims = handleClaimRequests(this.self);
+		const stopPortUpdates = 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._cleanup = () => {
+			stopClaims();
+			stopPortUpdates();
 		};
-	};
-}
+		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/sw-http-adapter.ts
 /**
-* Embeds a hidden relay iframe, establishes a MessageChannel with it, and
-* returns the port to be used with `initHttpService` / `callHttpService`.
+* The page side of the same-origin ServiceWorker: registers the worker, and
+* attaches handler links to it.
+*
+* - `register(prefix, handler)` serves a handler in this page, under
+*   `<scope>/<key>/...`.
+* - `attachWorker(worker)` links a Dedicated Worker that runs
+*   `serveHttpInWorker(handler)`: the ServiceWorker then talks to the worker
+*   directly, and this page carries nothing.
+* - `connectWebSocket(url, protocols)` and `WebSocket` open sockets to
+*   handlers, through the ServiceWorker or straight to a handler of this page.
+*
+* Links are attached again whenever the ServiceWorker asks (after a restart),
+* and requests in flight on a handler that dies fail at once.
 */
-async function newRemoteRelayChannel({ baseUrl = new URL("../public-relay/", moduleUrl), url = new URL("relay.html", baseUrl), container = document.body } = {}) {
-	const messageChannel = new MessageChannel();
-	const { iframe, promise } = newIFrame(url);
-	Object.assign(iframe.style, {
-		position: "fixed",
-		width: "1px",
-		height: "1px",
-		top: "-1000px",
-		left: "-1000px",
-		display: "block",
-		opacity: "0",
-		border: "none",
-		outline: "none"
-	});
-	container.appendChild(iframe);
-	promise.then(() => {
-		iframe.contentWindow?.postMessage({ type: "CONNECT" }, "*", [messageChannel.port1]);
-	});
-	return {
-		baseUrl,
-		port: messageChannel.port2,
-		close: () => {
-			iframe.parentElement?.removeChild(iframe);
-			messageChannel.port1.close();
-			messageChannel.port2.close();
+var SwHttpAdapter = class {
+	options;
+	_handlers = /* @__PURE__ */ new Map();
+	_endpoint;
+	_ownerLock = newLockName("webrun-http-owner");
+	_id;
+	_owner = crypto.randomUUID();
+	_workers = /* @__PURE__ */ new Set();
+	_releaseOwner;
+	_serviceWorkerUrl;
+	_serviceWorker;
+	_registration;
+	_registrationPromise;
+	_cleanup = [];
+	_attaching;
+	_routerLock;
+	_WebSocket;
+	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");
+		this._id = options.id ?? `page:${crypto.randomUUID()}`;
+		this._endpoint = new HandlerEndpoint((request) => this._handleHttpRequest(request), { streamTimeout: options.streamTimeout });
+	}
+	get key() {
+		return this.options.key;
+	}
+	get scope() {
+		return this.options.scope ?? new URL("./", this.serviceWorkerUrl).pathname;
+	}
+	/**
+	* The scope as a url on the worker's origin. Resolved against the worker's
+	* own url when one is given, not against this module's: a bundle that is
+	* not an ES module (an IIFE, Theia's frontend) has no `import.meta.url`, and
+	* `new URL(scope, undefined)` threw `Invalid URL` there. Only without a
+	* worker url does the module's location decide (its default `sw-worker.js`
+	* sits next to it).
+	*/
+	get rootUrl() {
+		const base = this.options.serviceWorkerUrl ? this.serviceWorkerUrl : import.meta.url;
+		return new URL(this.scope, base);
+	}
+	get serviceWorkerUrl() {
+		if (!this._serviceWorkerUrl) {
+			const url = this.options.serviceWorkerUrl ? resolveWorkerUrl(this.options.serviceWorkerUrl) : new URL("./sw-worker.js", this.rootUrl);
+			this._serviceWorkerUrl = `${url}`;
+		}
+		return this._serviceWorkerUrl;
+	}
+	/**
+	* Registers the worker and waits until it is activated and controls this
+	* page, then attaches this page's handler link. The page must be controlled,
+	* because only a controlled page's `fetch()` reaches the worker. When the
+	* page loaded uncontrolled (a hard reload does that), the worker is asked to
+	* claim it. Rejects with a `ServiceWorkerControlError` when that fails or
+	* `timeout` passes (`reason` says which step); a later `start()` tries
+	* again.
+	*/
+	async start() {
+		if (!this._registrationPromise) this._registrationPromise = (async () => {
+			const registration = await navigator.serviceWorker.register(this.serviceWorkerUrl, { scope: this.scope });
+			this._registration = registration;
+			const stopListening = handleChannelCalls(navigator.serviceWorker, NEED_LINKS_CALL, async (_event, params) => {
+				await this.relink(params?.routerLock);
+				return true;
+			});
+			const onControllerChange = () => {
+				const controller = navigator.serviceWorker.controller;
+				if (controller) this._serviceWorker = controller;
+			};
+			navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+			this._cleanup.push(stopListening, () => navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange));
+			const timeout = this.options.timeout ?? 3e4;
+			const deadline = Date.now() + timeout;
+			try {
+				this._serviceWorker = await awaitServiceWorkerControl(registration, {
+					timeout,
+					reloadIfUncontrolled: this.options.reloadIfUncontrolled
+				});
+				this._releaseOwner ??= await holdLock(this._ownerLock);
+				await withDeadline(deadline, this._attachPage(), () => new ServiceWorkerControlError("unresponsive", `ServiceWorker "${this._serviceWorker?.scriptURL}" controls this page but did not answer the UPDATE_COMMUNICATION_PORT handshake within ${timeout} ms. Check that the worker script runs this package's same-origin dispatcher (it importScripts \`sw-worker.js\`, or calls \`startHttpDispatcher\`).`));
+			} catch (error) {
+				for (const cleanup of this._cleanup.splice(0)) cleanup();
+				this._registration = void 0;
+				this._registrationPromise = void 0;
+				throw error;
+			}
+		})();
+		return this._registrationPromise;
+	}
+	/** Detaches every link, and unregisters the worker. */
+	async stop() {
+		for (const cleanup of this._cleanup.splice(0)) cleanup();
+		for (const worker of [...this._workers]) await worker.detach().catch(() => {});
+		const sw = this._serviceWorker;
+		if (sw) await callChannel(sw, DETACH_CALL, {
+			key: this.key,
+			id: this._id,
+			owner: this._owner
+		}).catch(() => {});
+		await this._endpoint.unlink();
+		this._releaseOwner?.();
+		this._releaseOwner = void 0;
+		const registration = this._registration;
+		this._registration = void 0;
+		this._registrationPromise = void 0;
+		try {
+			await registration?.unregister();
+		} catch (error) {
+			console.log("Service Worker unregistration failed: ", error);
+		}
+	}
+	/**
+	* 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);
+			}
+		};
+	}
+	/**
+	* Links a Dedicated Worker that runs `serveHttpInWorker(handler)` as a
+	* handler of `key`. The ServiceWorker sends it requests directly, without
+	* this page relaying anything, so a busy or throttled page does not slow
+	* them down.
+	*/
+	async attachWorker(worker, options = {}) {
+		await this.start();
+		const controls = [];
+		let retry;
+		const { control, ownerLock } = await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				clearInterval(retry);
+				for (const port of controls) port.close();
+				reject(/* @__PURE__ */ new Error("The worker did not answer within the timeout. Does it call serveHttpInWorker()?"));
+			}, this.options.timeout ?? 3e4);
+			const hello = () => {
+				const channel = new MessageChannel();
+				controls.push(channel.port1);
+				channel.port1.onmessage = (event) => {
+					const message = event.data;
+					if (message?.type !== "ready") return;
+					clearTimeout(timer);
+					clearInterval(retry);
+					for (const port of controls) if (port !== channel.port1) port.close();
+					resolve({
+						control: channel.port1,
+						ownerLock: message.ownerLock
+					});
+				};
+				worker.postMessage({ type: WORKER_HELLO }, [channel.port2]);
+			};
+			hello();
+			retry = setInterval(hello, 500);
+		});
+		const key = options.key ?? this.key;
+		const id = options.id ?? `worker:${crypto.randomUUID()}`;
+		for (const old of [...this._workers]) if (old.key === key && old.id === id) old.retire();
+		const link = new WorkerLinkImpl(this, control, {
+			key,
+			id,
+			owner: crypto.randomUUID(),
+			meta: options.meta,
+			ownerLock
+		});
+		this._workers.add(link);
+		await link.attach();
+		return link;
+	}
+	/**
+	* Opens the transport of a socket to the handler `url` routes to: a handler
+	* of this page directly, any other through the ServiceWorker. Resolves once
+	* the handler accepted. An arrow function, so it can be handed around:
+	* `createWebSocketClass(adapter.connectWebSocket)`.
+	*/
+	connectWebSocket = async (url, protocols = []) => {
+		const httpUrl = new URL(`${url}`, globalThis.location?.href);
+		if (httpUrl.protocol === "ws:") httpUrl.protocol = "http:";
+		else if (httpUrl.protocol === "wss:") httpUrl.protocol = "https:";
+		const local = this._findHandler(`${httpUrl}`);
+		if (local) {
+			const result = await serveWebSocketUpgrade(local, {
+				url: `${httpUrl}`,
+				protocols
+			});
+			if (!result.ok) throw new Error(result.message);
+			return {
+				port: result.port,
+				protocol: result.protocol
+			};
 		}
+		await this.start();
+		return await callChannelWithin(this._callTimeout(), this._worker(), WS_CONNECT_CALL, {
+			url: `${httpUrl}`,
+			protocols
+		});
 	};
-	function newIFrame(src) {
-		const iframe = document.createElement("iframe");
-		iframe.src = `${src}`;
-		Object.assign(iframe.style, {
-			padding: "0",
-			margin: "0",
-			border: "none",
-			outline: "none",
-			width: "100%",
-			height: "100%"
+	/**
+	* A WHATWG `WebSocket` class whose sockets reach this adapter's handlers:
+	* `new adapter.WebSocket(`${baseUrl}chat`, ["v1"])`. The global
+	* `WebSocket` is left alone.
+	*/
+	get WebSocket() {
+		this._WebSocket ??= createWebSocketClass(this.connectWebSocket, this.options.webSocket);
+		return this._WebSocket;
+	}
+	/**
+	* Attaches again every link not made for the router holding
+	* `currentRouterLock` (every link, without it). The ServiceWorker asks for
+	* this after a restart; a page may call it too.
+	*/
+	async relink(currentRouterLock) {
+		if (!this._registrationPromise) return;
+		const stale = (routerLock) => currentRouterLock === void 0 || routerLock !== currentRouterLock;
+		const jobs = [];
+		if (stale(this._routerLock)) jobs.push(this._attachPage());
+		for (const worker of this._workers) if (stale(worker.routerLock)) jobs.push(worker.attach());
+		await Promise.allSettled(jobs);
+	}
+	/** @internal Posts a plain message to the ServiceWorker, which starts it if stopped. */
+	_poke(type) {
+		try {
+			this._worker().postMessage({ type });
+		} catch {}
+	}
+	/** @internal */
+	_worker() {
+		const worker = navigator.serviceWorker.controller ?? this._serviceWorker ?? this._registration?.active;
+		if (!worker) throw new Error("The ServiceWorker is not running; call start() first");
+		return worker;
+	}
+	/** @internal */
+	_forget(link) {
+		this._workers.delete(link);
+	}
+	/** @internal How long a call to the ServiceWorker may take. */
+	_callTimeout() {
+		return this.options.timeout ?? 3e4;
+	}
+	_attachPage() {
+		this._attaching ??= (async () => {
+			try {
+				const down = new MessageChannel();
+				const ctl = new MessageChannel();
+				const params = {
+					wire: HTTP_LINK_PROTOCOL,
+					key: this.key,
+					id: this._id,
+					owner: this._owner,
+					ownerLock: this._releaseOwner && locksAvailable() ? this._ownerLock : void 0,
+					meta: this.options.meta,
+					ctl: true
+				};
+				const reply = await callChannelWithin(this._callTimeout(), this._worker(), ATTACH_CALL, params, down.port1, ctl.port1);
+				checkReply(reply, this._worker());
+				await this._endpoint.link(this.key, {
+					down: down.port2,
+					ctl: ctl.port2
+				}, reply.routerLock);
+				this._routerLock = reply.routerLock;
+			} finally {
+				this._attaching = void 0;
+			}
+		})();
+		return this._attaching;
+	}
+	_findHandler(url) {
+		for (const [urlPrefix, handler] of this._handlers) if (url.indexOf(urlPrefix) === 0) return handler;
+	}
+	async _handleHttpRequest(request) {
+		const handler = this._findHandler(request.url);
+		if (handler) return await handler(request);
+		return new Response(null, {
+			status: 404,
+			statusText: "Error 404: Not found"
 		});
-		return {
-			iframe,
-			promise: new Promise((resolve, reject) => {
-				iframe.onerror = () => reject(/* @__PURE__ */ new Error(`Failed to load ${src}`));
-				iframe.onload = () => resolve(iframe);
-			})
+	}
+};
+var WorkerLinkImpl = class {
+	_adapter;
+	_control;
+	key;
+	id;
+	owner;
+	routerLock;
+	_meta;
+	_ownerLock;
+	_attaching;
+	_detached = false;
+	constructor(_adapter, _control, init) {
+		this._adapter = _adapter;
+		this._control = _control;
+		this.key = init.key;
+		this.id = init.id;
+		this.owner = init.owner;
+		this._meta = init.meta;
+		this._ownerLock = init.ownerLock;
+		_control.onmessage = (event) => {
+			const message = event.data;
+			if (message?.type === "relink") {
+				this._adapter._poke(WAKE_MESSAGE);
+				this.attach().catch(() => {});
+			} else if (message?.type === "keepalive") this._adapter._poke(KEEPALIVE_MESSAGE);
 		};
 	}
-}
-async function initializeConnection({ key, communicationPort, ...options }) {
-	const channel = new MessageChannel();
-	if (!await callChannel(communicationPort, "CONNECT", {
-		key,
-		...options
-	}, channel.port2)) {
-		channel.port1.close();
-		channel.port2.close();
-		return null;
+	/**
+	* Forgets this link without telling the ServiceWorker: another attachment
+	* took its slot, and the ServiceWorker retires it by itself.
+	*/
+	retire() {
+		this._detached = true;
+		this._adapter._forget(this);
+		this._control.onmessage = null;
 	}
-	return channel.port1;
+	/** Makes fresh channels and attaches them; the worker gets its ends. */
+	attach() {
+		if (this._detached) return Promise.resolve();
+		this._attaching ??= (async () => {
+			try {
+				if (this._ownerLock) {
+					const held = await heldLockNames();
+					if (held && !held.has(this._ownerLock)) {
+						this.retire();
+						return;
+					}
+				}
+				const down = new MessageChannel();
+				const ctl = new MessageChannel();
+				const up = new MessageChannel();
+				const params = {
+					wire: HTTP_LINK_PROTOCOL,
+					key: this.key,
+					id: this.id,
+					owner: this.owner,
+					ownerLock: this._ownerLock,
+					meta: this._meta,
+					ctl: true,
+					up: true
+				};
+				const sw = this._adapter._worker();
+				const reply = await callChannelWithin(this._adapter._callTimeout(), sw, ATTACH_CALL, params, down.port1, ctl.port1, up.port1);
+				checkReply(reply, sw);
+				this.routerLock = reply.routerLock;
+				this._control.postMessage({
+					type: "link",
+					key: this.key,
+					routerLock: reply.routerLock
+				}, [
+					down.port2,
+					ctl.port2,
+					up.port2
+				]);
+			} finally {
+				this._attaching = void 0;
+			}
+		})();
+		return this._attaching;
+	}
+	async drain({ ms } = {}) {
+		if (this._detached) return;
+		this._detached = true;
+		this._adapter._forget(this);
+		try {
+			await callChannel(this._adapter._worker(), DRAIN_CALL, {
+				key: this.key,
+				id: this.id,
+				owner: this.owner,
+				ms
+			});
+		} finally {
+			this._unlink();
+		}
+	}
+	async detach() {
+		if (this._detached) return;
+		this._detached = true;
+		this._adapter._forget(this);
+		await callChannel(this._adapter._worker(), DETACH_CALL, {
+			key: this.key,
+			id: this.id,
+			owner: this.owner
+		}).catch(() => {});
+		this._unlink();
+	}
+	_unlink() {
+		this._control.postMessage({
+			type: "unlink",
+			key: this.key
+		});
+		this._control.onmessage = null;
+	}
+};
+function checkReply(reply, sw) {
+	if (reply?.accepted === "webrun-http-link/2") return;
+	throw new ServiceWorkerControlError("incompatible", `ServiceWorker "${sw.scriptURL}" answered the handshake but does not speak ${HTTP_LINK_PROTOCOL}: it runs an older version of @statewalker/webrun-http-browser. Reload the page once the updated worker is active.`);
 }
-async function registerConnectionsHandler({ key, path, handler, communicationPort }) {
-	const [register, cleanup] = newRegistry();
-	await callChannel(communicationPort, "REGISTER", path == null ? { key } : {
-		key,
-		path
+//#endregion
+//#region src/sw/sw-websocket.ts
+/**
+* Opens the transport of a socket through the ServiceWorker controlling this
+* page, for a page that has no adapter of its own: content a handler serves
+* under the same-origin dispatcher, or under a relay. The ServiceWorker
+* routes `url` like a fetch, and the handler accepts or refuses the upgrade.
+*/
+async function connectWebSocketThroughServiceWorker(url, protocols = [], container = navigator.serviceWorker) {
+	const worker = container.controller;
+	if (!worker) throw new Error("This page is not controlled by a ServiceWorker");
+	const httpUrl = new URL(`${url}`, globalThis.location?.href);
+	if (httpUrl.protocol === "ws:") httpUrl.protocol = "http:";
+	else if (httpUrl.protocol === "wss:") httpUrl.protocol = "https:";
+	return await callChannel(worker, WS_CONNECT_CALL, {
+		url: `${httpUrl}`,
+		protocols
 	});
-	register(() => callChannel(communicationPort, "UNREGISTER", { key }));
-	register(handleKeyedChannelCalls(communicationPort, "CONNECT", key, async (event, data, port) => {
-		return await handler(event, data, port);
-	}));
-	return cleanup;
 }
 /**
-* `handleChannelCalls`, but only for calls whose `params.key` is `key`.
-*
-* ONE CONNECTION CARRIES SEVERAL SERVICES — an app at `/` and a mesh gateway
-* at `/peers/` over one relay iframe is the shape mounts exist for. Plain
-* `handleChannelCalls` cannot do that: every listener it has for a call type
-* runs on every message, and each is handed the SAME reply port and the SAME
-* transferred stream port. Two services then both serve the one channel the
-* worker is reading, and its response comes back with both bodies in it.
+* A WHATWG `WebSocket` class over `connectWebSocketThroughServiceWorker`.
+* Install it where the page's code expects `WebSocket`, e.g.
+* `globalThis.WebSocket = serviceWorkerWebSocketClass()` in content that only
+* talks to its own handlers.
+*/
+function serviceWorkerWebSocketClass(options) {
+	return createWebSocketClass((url, protocols) => connectWebSocketThroughServiceWorker(url, protocols), options);
+}
+//#endregion
+//#region src/sw/worker-service.ts
+/**
+* Serves `handler` from a Dedicated Worker, on the links the page attaches
+* with `adapter.attachWorker(worker)`:
 *
-* WHY NOT A FILTER INSIDE THE HANDLER. Returning `false` for a foreign key
-* does not help: `handleChannelCalls` still replies, `callChannel` resolves on
-* the FIRST reply it receives, and the loser's `false` reaches the worker as
-* "the client refused" — a 403, non-deterministically. A service that is not
-* the addressee must stay SILENT and leave the transferred port untouched.
+* ```ts
+* // worker.ts
+* const service = serveHttpInWorker(async (request) => new Response("hi"));
+* ```
 *
-* Local to this module on purpose. `handleChannelCalls` is also used where a
-* call carries no key (REGISTER/UNREGISTER, and the worker's own CONNECT in
-* `index-sw.ts`, which is the other direction), so its semantics must not
-* change.
+* The worker holds an owner lock while it lives, so the ServiceWorker notices
+* at once when it is terminated. It watches the ServiceWorker's router lock,
+* and asks its page to attach it again when its links died and a call waits.
+* While calls through the router are in flight it asks its page every 20 s to
+* keep the ServiceWorker awake — only a message to the ServiceWorker object
+* counts as an event, and a worker cannot post one.
 */
-function handleKeyedChannelCalls(target, callType, key, handler) {
-	const listener = async (event) => {
-		const data = event.data;
-		if (!data || data.type !== callType) return;
-		if (data.params?.key !== key) return;
-		const [port, ...transfers] = event.ports ?? [];
-		const response = {};
-		try {
-			response.result = await handler(event, data.params, ...transfers);
-		} catch (error) {
-			response.error = serializeError(error);
+function serveHttpInWorker(handler, options = {}) {
+	const scope = options.scope ?? globalThis;
+	const ownerLock = newLockName("webrun-http-owner");
+	const held = holdLock(ownerLock);
+	const controls = /* @__PURE__ */ new Set();
+	const tellPages = (message) => {
+		for (const control of controls) control.postMessage(message);
+	};
+	const endpoint = new HandlerEndpoint(handler, {
+		...options,
+		requestRelink: () => tellPages({ type: "relink" }),
+		keepAlive: () => tellPages({ type: "keepalive" })
+	});
+	const onMessage = (event) => {
+		const { data, ports } = event;
+		if (data?.type !== "webrun-http:worker-hello") return;
+		const control = ports?.[0];
+		if (!control) return;
+		controls.add(control);
+		control.onmessage = (message) => {
+			const msg = message.data;
+			if (msg?.type === "link") {
+				const [down, ctl, up] = message.ports;
+				if (down) endpoint.link(msg.key, {
+					down,
+					ctl,
+					up
+				}, msg.routerLock);
+			} else if (msg?.type === "unlink") endpoint.unlink(msg.key);
+		};
+		held.then(() => control.postMessage({
+			type: "ready",
+			ownerLock: locksAvailable() ? ownerLock : void 0
+		}));
+	};
+	scope.addEventListener("message", onMessage);
+	const baseUrl = () => globalThis.location?.href;
+	const connectWebSocket = (url, protocols = []) => {
+		const httpUrl = new URL(`${url}`, baseUrl());
+		if (httpUrl.protocol === "ws:") httpUrl.protocol = "http:";
+		else if (httpUrl.protocol === "wss:") httpUrl.protocol = "https:";
+		return endpoint.connectWebSocket(`${httpUrl}`, protocols);
+	};
+	let WebSocketClass;
+	return {
+		fetch(input, init) {
+			const request = input instanceof Request && init === void 0 ? input : new Request(input instanceof Request ? input : new URL(`${input}`, baseUrl()), init);
+			return endpoint.fetch(request);
+		},
+		connectWebSocket,
+		get WebSocket() {
+			WebSocketClass ??= createWebSocketClass(connectWebSocket, options.webSocket);
+			return WebSocketClass;
+		},
+		get linked() {
+			return endpoint.linked;
+		},
+		async close() {
+			scope.removeEventListener("message", onMessage);
+			await endpoint.close();
+			for (const control of controls) control.close();
+			controls.clear();
+			(await held)();
 		}
-		port?.postMessage(response);
 	};
-	target.addEventListener("message", listener);
-	target.start?.();
-	return () => target.removeEventListener("message", listener);
 }
 //#endregion
-export { CLAIM_CALL, DEFAULT_SERVICE_WORKER_TIMEOUT, DuplexSiteBuilder, HttpError, HttpParseError, PEER_ERROR_HEADER, ServiceWorkerControlError, TransportClosedError, awaitActiveServiceWorker, awaitServiceWorkerControl, callChannel, callHttpService, collect, collectBytes, collectString, decodeJsonl, decodeMessage, decodeText, defaultCodec, deserializeError, emulateMux, encodeJsonl, encodeMessage, encodeText, fetchOverDuplex, fromReadableStream, getRelayWindowMessageHandler, handleChannelCalls, handleClaimRequests, handleHttpRequests, handleStreams, httpCodec, httpFetch, httpServe, initHttpService, initServiceWorker, initializeConnection, joinLines, jsonEnvelopeCodec, map, newAsyncGenerator, newCreditGrantor, newCreditLedger, newHttpClientStub, newHttpCodec, newHttpServerStub, newInvokationChannel, newRegistry, newRemoteRelayChannel, newServiceWorkerPort, newSniffingCodec, normalizeToUint8Array, recieveIterator, registerConnectionsHandler, sendHttpRequest, sendIterator, sendStream, serializeError, serveFetchOverDuplex, splitLines, splitServiceUrl, toChunks, toReadableStream };
+export { CLAIM_CALL, DEFAULT_CLOSE_TIMEOUT_MS, DEFAULT_HEARTBEAT_MS, DEFAULT_SERVICE_WORKER_TIMEOUT, DuplexSiteBuilder, HANDLER_LOST_MESSAGE, HTTP_LINK_PROTOCOL, HandlerEndpoint, HandlerTable, HttpError, HttpParseError, LinkLostError, PEER_ERROR_HEADER, PortRendezvous, ROUTER_LOST_MESSAGE, ServerWebSocket, ServiceWorkerControlError, SwHttpAdapter, SwHttpDispatcher, SwPortDispatcher, SwPortHandler, TransportClosedError, WS_PORT_PROTOCOL_VERSION, WS_VERSION_HEADER, WsCloseEvent, answerConnect, awaitActiveServiceWorker, awaitServiceWorkerControl, callChannel, callChannelWithin, callHttpService, callWebSocketService, collect, collectBytes, collectString, connectHttpLink, connectWebSocketThroughServiceWorker, createWebSocketClass, decodeJsonl, decodeMessage, decodeText, defaultCodec, deserializeError, emulateMux, encodeJsonl, encodeMessage, encodeText, fetchOverDuplex, fromReadableStream, getRelayWindowMessageHandler, handleChannelCalls, handleClaimRequests, handleHttpRequests, handleStreams, holdLock, httpCodec, httpFetch, httpServe, initHttpService, initServiceWorker, initializeConnection, isWebSocketUpgrade, joinLines, jsonEnvelopeCodec, leastInflightRoute, locksAvailable, map, newAsyncGenerator, newCreditGrantor, newCreditLedger, newHttpClientStub, newHttpCodec, newHttpServerStub, newInvokationChannel, newLockName, newRegistry, newRemoteRelayChannel, newServiceWorkerPort, newSniffingCodec, newWebSocketUpgradeRequest, normalizeToUint8Array, recieveIterator, registerConnectionsHandler, relayWebSocketClass, requestedProtocols, sendHttpRequest, sendIterator, sendOverConnection, sendStream, serializeError, serveFetchOverDuplex, serveHttpInWorker, serveHttpLink, serveWebSocketUpgrade, serviceWorkerWebSocketClass, splitLines, splitServiceUrl, startHttpDispatcher, takePort, takeUpgrade, toChunks, toReadableStream, trackedLink, unwrapTransfer, upgradeWebSocket, watchLock, withHeaders, withTransfer };