@statewalker/webrun-http-browser 0.6.5 → 0.7.0

package/dist/sw.js

@@ -281,6 +281,34 @@ async function sendIterator(send, it) {
 		});
 	}
 }
+const DEFAULT_CHUNK_SIZE = 16384;
+/**
+* Curried `Duplex`-shaped transformer that splits incoming `Uint8Array`s into
+* chunks no larger than `size` bytes. Empty input chunks are skipped; small
+* input chunks pass through unchanged (zero-copy `subarray` views are used
+* when splitting, so no allocation per chunk).
+*
+* Use to respect transport MTUs before reaching `channel.send`. Reassembly on
+* the receive side is not needed — consumers iterate a continuous byte stream.
+*/
+function toChunks(size = DEFAULT_CHUNK_SIZE) {
+	if (!(Number.isInteger(size) && size > 0)) throw new RangeError(`toChunks: size must be a positive integer, got ${size}`);
+	return async function* (input) {
+		for await (const block of input) {
+			if (block.byteLength === 0) continue;
+			if (block.byteLength <= size) {
+				yield block;
+				continue;
+			}
+			let offset = 0;
+			while (offset < block.byteLength) {
+				const end = Math.min(offset + size, block.byteLength);
+				yield block.subarray(offset, end);
+				offset = end;
+			}
+		}
+	};
+}
 //#endregion
 //#region ../webrun-http-streams/dist/index.js
 const CR = 13;
@@ -1032,10 +1060,160 @@ function newSniffingCodec(options) {
 		}
 	};
 }
-newSniffingCodec({
+/**
+* Writes HTTP/1.1; accepts HTTP/1.1 or the legacy JSON envelope. Used whenever
+* no `codec` option is supplied.
+*/
+const defaultCodec = newSniffingCodec({
 	write: httpCodec,
 	accept: [httpCodec, jsonEnvelopeCodec]
 });
+/** Carries the serialized JS error between two webrun peers. */
+const PEER_ERROR_HEADER = "x-webrun-error";
+/** Hard cap on the peer-error header (M3): see `encodeErrorResponse`. */
+const MAX_DETAIL_CHARS = 4096;
+/**
+* JSON with every non-printable-ASCII character escaped, so the result is a
+* legal latin-1 header value whatever the error message contained.
+*/
+function asciiJson(value) {
+	return JSON.stringify(value).replace(/[^\x20-\x7E]/g, (ch) => `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+/**
+* Decision 13: a real HTTP peer cannot receive a JavaScript exception, only a
+* response. So an uncaught handler error becomes a conforming 500 whose body
+* carries the message, with the serialized error in a namespaced header that
+* another webrun peer re-throws from.
+*/
+function encodeErrorResponse(codec, error, method, status = 500, statusText = "Internal Server Error") {
+	const serialized = serializeError(error);
+	let detail = asciiJson(serialized);
+	if (detail.length > MAX_DETAIL_CHARS) detail = asciiJson({ message: serialized.message });
+	if (detail.length > MAX_DETAIL_CHARS) detail = detail.slice(0, MAX_DETAIL_CHARS);
+	const message = serialized.message ?? statusText;
+	return codec.encodeResponse({
+		status,
+		statusText,
+		headers: [["Content-Type", "text/plain; charset=utf-8"], [PEER_ERROR_HEADER, detail]]
+	}, [new TextEncoder().encode(message)], { method });
+}
+/**
+* `output` is the `Duplex` call's own generator — one logical call, per the
+* `Duplex` contract in `@statewalker/webrun-streams`: "Consumer `.return()`
+* on the output → producer's `finally` runs." On a mux transport
+* (`emulateMux`), that `finally` is what frees the stream-table slot; skip it
+* and every peer-error response leaks one slot, unboundedly, until the mux
+* itself is exhausted (`maxStreams` reached, every further call rejected).
+*
+* Cancelling `output` here — not inside the codec's own decode logic — is
+* deliberate. `codec.decodeResponse` already pulled from `output` to read the
+* head before this function runs, so unlike the body case above there's no
+* suspended-start no-op to worry about. And it's safe specifically *because*
+* this is the client's own response-only generator: the request was already
+* fully sent before we got here, so there is nothing left to write on it.
+* The equivalent is NOT safe inside `src/http1/decode.ts`'s `ByteReader` —
+* that code also runs when a caller wires `codec.decodeRequest`/
+* `decodeResponse` directly onto a raw bidirectional socket (see
+* `tests/http1-node-interop.test.ts`), where the *same* object is read from
+* and then written back to (a server reads the request, then replies on the
+* same socket); cancelling the read side there tears down the whole
+* connection out from under the pending write. That was tried and reverted —
+* see the Task 11 report for the "socket hang up" failure it caused.
+*/
+async function throwIfPeerError(result, output) {
+	const found = result.envelope.headers.find(([k]) => k.toLowerCase() === PEER_ERROR_HEADER);
+	if (!found) return;
+	await discard(result.body);
+	try {
+		await output.return?.(void 0);
+	} catch {}
+	let payload;
+	try {
+		payload = JSON.parse(found[1]);
+	} catch {
+		payload = { message: found[1] };
+	}
+	throw deserializeError(payload);
+}
+/**
+* Initiate an HTTP call over a `Duplex`. The caller's `call: Duplex` is
+* obtained from any `webrun-streams-*` adapter's `connect`. Returns the
+* response envelope and an async iterable over the response body bytes.
+*
+* The call is one logical Duplex invocation; multiplexing of concurrent
+* calls is the adapter's concern (native or `emulateMux`).
+*/
+async function httpFetch(call, env, body, options = {}) {
+	const codec = options.codec ?? defaultCodec;
+	const output = call(codec.encodeRequest(env, body));
+	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`.
+*/
+function httpServe(handler, options = {}) {
+	const codec = options.codec ?? defaultCodec;
+	return async function* httpHandlerDuplex(input) {
+		let decoded;
+		try {
+			decoded = await codec.decodeRequest(input);
+		} catch (error) {
+			if (!(error instanceof HttpParseError)) throw error;
+			yield* encodeErrorResponse(error.codec ?? codec, error, "GET", 400, "Bad Request");
+			return;
+		}
+		const replyCodec = decoded.codec ?? codec;
+		let result;
+		try {
+			result = await handler(decoded.envelope, decoded.body);
+		} catch (error) {
+			yield* encodeErrorResponse(replyCodec, error, decoded.envelope.method);
+			return;
+		}
+		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 {}
+		}
+	};
+}
 /**
 * The one place that knows a runtime may not implement request body streams,
 * and the buffering both fallbacks need. `fetch.ts` and `http-stubs.ts` each
@@ -1167,580 +1345,3105 @@ function newHttpClientStub(send) {
 	};
 }
 /**
-* Returns a server-side transport handler. It deserializes the incoming
-* request envelope, delegates to `handler`, and serializes the response.
+* Connection-scoped headers. The codec surfaces them verbatim (decision 12),
+* but they are meaningless to a `Request`/`Response`, and re-emitting them
+* from a relay would corrupt its framing.
+*/
+const HOP_BY_HOP = /* @__PURE__ */ new Set([
+	"connection",
+	"host",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+]);
+function forwardableHeaders(headers) {
+	return headers.filter(([name]) => !HOP_BY_HOP.has(name.toLowerCase()));
+}
+function headersToArray(headers) {
+	const out = [];
+	headers.forEach((value, key) => {
+		out.push([key, value]);
+	});
+	return out;
+}
+async function* readableToAsyncIterable(stream) {
+	if (!stream) return;
+	const reader = stream.getReader();
+	let consumed = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				consumed = true;
+				return;
+			}
+			if (value) yield value;
+		}
+	} finally {
+		if (!consumed) try {
+			await reader.cancel();
+		} catch {}
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
+function asyncIterableToReadable(iter) {
+	const it = iter[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await it.next();
+				if (done) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(value);
+			} catch (err) {
+				controller.error(err);
+			}
+		},
+		async cancel() {
+			await it.return?.();
+		}
+	});
+}
+/**
+* Run a `Request` through a `Duplex` call and reconstruct the `Response` on
+* the other side. The request's `signal` is plumbed into the body iteration —
+* abort terminates the underlying call.
+*/
+async function fetchOverDuplex(call, request, options = {}) {
+	if (request.signal?.aborted) throw abortReason$1(request.signal);
+	const env = {
+		url: request.url,
+		method: request.method,
+		headers: headersToArray(request.headers)
+	};
+	let body;
+	if (request.body != null) body = readableToAsyncIterable(request.body);
+	else if (!supportsRequestStreams()) {
+		const buffered = new Uint8Array(await request.arrayBuffer());
+		if (buffered.byteLength > 0) body = [buffered];
+	}
+	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 release?.();
+		return new Response(null, responseInit);
+	}
+	return new Response(asyncIterableToReadable(withAbort(respBody, request.signal)), responseInit);
+}
+/**
+* Wrap a `(Request) => Promise<Response>` handler as a `Duplex` so it can be
+* registered with any `webrun-streams-*` adapter's `serve`.
 */
-function newHttpServerStub(handler) {
-	return async (envelopeOrPromise) => {
-		const { options, content } = await envelopeOrPromise;
-		const { url, method, headers = [], ...rest } = options;
-		const { mode: _mode, ...forwardable } = rest;
-		const requestHeaders = new Headers();
-		for (const [key, value] of headers) requestHeaders.append(key, value);
-		const hasBody = method !== "GET" && method !== "HEAD" && method !== "OPTIONS";
-		const requestInit = {
-			...forwardable,
-			method,
-			headers: requestHeaders
+function serveFetchOverDuplex(handler, options = {}) {
+	return httpServe(async (env, body) => {
+		const reqInit = {
+			method: env.method,
+			headers: forwardableHeaders(env.headers)
+		};
+		if (env.method !== "GET" && env.method !== "HEAD") {
+			if (supportsRequestStreams()) {
+				reqInit.body = asyncIterableToReadable(body);
+				reqInit.duplex = "half";
+			} else reqInit.body = await collectBytes(body);
+		}
+		const response = await handler(new Request(env.url, reqInit));
+		const respEnv = {
+			status: response.status,
+			statusText: response.statusText,
+			headers: headersToArray(response.headers)
 		};
-		if (!hasBody) await discard(content);
-		else if (supportsRequestStreams()) {
-			requestInit.body = toReadableStream(content[Symbol.asyncIterator]());
-			requestInit.duplex = "half";
-		} else requestInit.body = await collectBytes(content);
-		const response = await handler(new Request(url, requestInit));
+		if (env.method === "HEAD" || env.method === "OPTIONS" || NULL_BODY_STATUSES.has(response.status)) {
+			await response.body?.cancel();
+			return {
+				envelope: respEnv,
+				body: void 0
+			};
+		}
 		return {
-			options: {
-				status: response.status,
-				statusText: response.statusText,
-				headers: Object.fromEntries([...response.headers])
-			},
-			content: response.body ? fromReadableStream(response.body) : (async function* () {})()
+			envelope: respEnv,
+			body: response.body ? readableToAsyncIterable(response.body) : void 0,
+			release: () => response.body?.cancel()
 		};
-	};
+	}, options);
+}
+async function* withAbort(iter, signal) {
+	if (!signal) {
+		yield* iter;
+		return;
+	}
+	for await (const chunk of iter) {
+		if (signal.aborted) throw abortReason$1(signal);
+		yield chunk;
+	}
+}
+function abortReason$1(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;
 }
 //#endregion
-//#region src/core/data-channels.ts
-const MESSAGE_TYPE_REQUEST = "REQUEST";
-const MESSAGE_TYPE_RESPONSE = "RESPONSE";
-let __invocationCounter = 0;
-function newInvokationChannel({ port, handler = () => {
-	throw new Error("Handler not implemented");
-}, onError = console.error, newCallId = () => ++__invocationCounter }) {
-	const requests = {};
-	const listener = async (event) => {
-		const data = event.data ?? {};
-		if (data.type === MESSAGE_TYPE_REQUEST) try {
-			const result = await handler(data.request, ...event.ports);
-			const [response, ...transfers] = Array.isArray(result) ? result : result !== void 0 ? [result] : [];
-			port.postMessage({
-				type: MESSAGE_TYPE_RESPONSE,
-				callId: data.callId,
-				response
-			}, transfers);
-		} catch (error) {
-			port.postMessage({
-				type: MESSAGE_TYPE_RESPONSE,
-				callId: data.callId,
-				error: serializeError(error)
-			});
-		}
-		else if (data.type === MESSAGE_TYPE_RESPONSE) {
-			const pending = requests[data.callId];
-			delete requests[data.callId];
-			if (!pending) return;
-			if (data.error) pending.reject(deserializeError(data.error));
-			else pending.resolve(data.response);
+//#region ../webrun-rpc/dist/index.js
+const closeSignals = /* @__PURE__ */ new WeakMap();
+/**
+* Internal: register a port's close signal. Called once by `bindBytesToPort`.
+*
+* @internal
+*/
+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;
 		}
-	};
-	const start = async () => {
-		try {
-			port.addEventListener("message", listener);
-			await port.start?.();
-		} catch (e) {
-			onError(e);
+		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 });
 		}
-	};
-	const close = async () => {
+	});
+	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 {
-			port.removeEventListener("message", listener);
-			await port.close?.();
+			result = await handler(params);
+			type = "response:result";
 		} catch (e) {
-			onError(e);
+			error = serializeError(e);
+			type = "response:error";
 		}
-	};
-	const invoke = (request = {}, ...transfers) => {
-		const callId = newCallId();
-		return new Promise((resolve, reject) => {
-			try {
-				requests[callId] = {
-					resolve,
-					reject
-				};
-				port.postMessage({
-					type: MESSAGE_TYPE_REQUEST,
-					callId,
-					request
-				}, transfers);
-			} catch (error) {
-				delete requests[callId];
-				reject(error);
-			}
+		port.postMessage({
+			callId,
+			channelName,
+			type,
+			result,
+			error
 		});
 	};
-	return {
-		start,
-		close,
-		invoke
-	};
+	port.addEventListener("message", onMessage);
+	return () => port.removeEventListener("message", onMessage);
 }
-async function* sendStream(communicationPort, input, params = {}) {
-	const messageChannel = new MessageChannel();
-	communicationPort.postMessage({
-		type: "START_CALL",
-		params
-	}, [messageChannel.port2]);
-	const channel = newStreamChannel(messageChannel.port1);
-	let drained = false;
+/**
+* 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;
+	}
+	signal.addEventListener("abort", onAbort, { once: true });
 	try {
-		await channel.start();
-		channel.sendAll(input);
-		yield* channel.recieveAll();
-		drained = true;
+		while (true) {
+			const r = await iter.next();
+			if (r.done) return;
+			if (signal.aborted) return;
+			yield r.value;
+		}
 	} finally {
-		if (!drained) channel.cancel();
-		await channel.close();
+		signal.removeEventListener("abort", onAbort);
 	}
 }
-function handleStreams(communicationPort, handler) {
-	const listener = async (event) => {
-		const { type, params } = event.data ?? {};
-		if (type !== "START_CALL") return;
-		const port = event.ports[0];
-		const channel = newStreamChannel(port);
+/**
+* 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 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";
+/**
+* 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 duplexOverPort(port, options = {}) {
+	return (input) => runCallerSide(port, input, options);
+}
+/**
+* Installs `handler` as the serving side of one stream on `port`. Returns an
+* idempotent teardown that abandons the stream and notifies the peer.
+*/
+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);
+}
+/**
+* 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();
+	});
+}
+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 {
-			await channel.start();
-			const response = await handler(channel.recieveAll(), params ?? {});
-			await channel.sendAll(response);
+			yield* inbound.stream;
 		} finally {
-			await channel.close();
+			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 {}
 		}
-	};
-	communicationPort.addEventListener("message", listener);
-	communicationPort.start?.();
-	return () => communicationPort.removeEventListener("message", listener);
+	})();
 }
-function newStreamChannel(port) {
-	let listeners = [];
-	let iterators = [];
-	const notifyAll = async (data) => {
-		for (const listener of listeners) await listener(data);
+/**
+* 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.
+*/
+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"));
 	};
-	/**
-	* Release whatever we are sending. NOT awaited: `.return()` on an async
-	* generator parked awaiting its own source is queued behind that pending
-	* `next()`, so awaiting it here would block the message handler — and the
-	* chunk that would unblock it can only arrive through that same handler.
-	*/
-	const cancelOutgoing = () => {
-		for (const it of [...iterators]) {
-			const iterable = it;
-			Promise.resolve(iterable.return?.()).catch(() => {});
+	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);
 		}
 	};
-	const channel = newInvokationChannel({
-		port,
-		handler: (data) => {
-			const message = data;
-			if (message?.cancel) {
-				cancelOutgoing();
-				return;
-			}
-			return notifyAll(message);
+}
+/**
+* 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.
+*/
+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 });
+}
+/**
+* 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 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;
 	});
-	const start = () => channel.start();
-	const cancel = () => {
-		channel.invoke({ cancel: true }).catch(() => {});
+	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 close = async () => {
-		await notifyAll({ done: true });
-		for (const it of [...iterators]) await it.return?.();
-		await channel.close();
+	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();
 	};
-	async function* recieveAll() {
-		yield* recieveIterator((deliver) => {
-			listeners.push(deliver);
-			return () => {
-				listeners = listeners.filter((l) => l !== deliver);
-			};
+	const onAbort = () => {
+		aborted = true;
+		abortReason = controller.signal.reason;
+		finished = true;
+		wake();
+		deliver?.({
+			done: true,
+			error: abortReason
 		});
-	}
-	async function sendAll(it) {
-		await sendIterator((chunk) => void channel.invoke(chunk), (async function* () {
-			try {
-				iterators.push(it);
-				yield* it;
-			} finally {
-				iterators = iterators.filter((i) => i !== it);
-			}
-		})());
-	}
+		resolveEnded();
+	};
+	controller.signal.addEventListener("abort", onAbort, { once: true });
 	return {
-		start,
-		close,
-		cancel,
-		recieveAll,
-		sendAll
+		stream: recieveIterator((d) => {
+			if (aborted) {
+				d({
+					done: true,
+					error: abortReason
+				});
+				return detach;
+			}
+			deliver = d;
+			wake();
+			return detach;
+		}),
+		stop: detach,
+		ended
 	};
 }
-//#endregion
-//#region src/http/http-send-recieve.ts
-async function* httpToIterator(envelopeOrPromise) {
-	const { options, content } = await envelopeOrPromise;
-	yield new TextEncoder().encode(JSON.stringify(options));
-	yield* content;
-}
-async function httpFromIterator(iterable) {
-	const it = (await iterable)[Symbol.asyncIterator]();
-	const { done, value } = await it.next();
-	let options = {};
-	if (!done && value) {
-		const str = new TextDecoder().decode(value);
-		options = JSON.parse(str);
+/**
+* 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 {
-		options,
-		content: { [Symbol.asyncIterator]() {
-			return it;
-		} }
+		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;
+		}
 	};
 }
 /**
-* Serve an `HttpHandler` over a `MessageTarget`, using this package's own
-* `handleStreams` transport.
-*
-* @deprecated Prefer the port stack in `@statewalker/webrun-rpc`: open a port
-* (`multiplexPort` over one pipe, or `transferPortMux` where the platform can
-* transfer a real `MessagePort`), turn it into a `Duplex` with
-* `serveDuplexOverPort`, and serve HTTP on that with
-* `httpServe(handler, options)` from `@statewalker/webrun-http-streams`.
-*
-* That path has backpressure; **this one does not.** `sendStream`'s chunk
-* sender discards the promise it is given, so a fast producer over a slow
-* consumer accumulates without bound. It also has no per-stream timeout and no
-* chunking to a transport's message ceiling.
+* 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.
 *
-* Kept for existing ServiceWorker setups built on the `MessageTarget` surface.
+* A transport that already multiplexes natively supplies its own `PortMux`
+* instead — this implementation is for transports that offer one pipe.
 */
-function handleHttpRequests(communicationPort, handler) {
-	const serverStub = newHttpServerStub(handler);
-	return handleStreams(communicationPort, async (it) => {
-		const envelope = await httpFromIterator(it);
-		return httpToIterator(await serverStub(envelope));
-	});
+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?.();
+		}
+	};
 }
 /**
-* Ship a `Request` over a `MessageTarget` and await the `Response`, using this
-* package's own `sendStream` transport.
+* 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.
 *
-* @deprecated Prefer the port stack in `@statewalker/webrun-rpc`: open a port
-* (`multiplexPort` over one pipe, or `transferPortMux` where the platform can
-* transfer a real `MessagePort`), turn it into a `Duplex` with
-* `duplexOverPort`, and drive HTTP over it with `httpFetch` from
-* `@statewalker/webrun-http-streams`.
+* 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.
 *
-* Same caveat as {@link handleHttpRequests}: the transport underneath this
-* helper has no backpressure, no per-stream timeout, and no chunking to a
-* transport's message ceiling. Kept for existing ServiceWorker setups.
+* 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.
 */
-async function sendHttpRequest(communicationPort, request) {
-	return await newHttpClientStub(async (req) => {
-		return await httpFromIterator(sendStream(communicationPort, httpToIterator(req)));
-	})(request);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/idb-keyval@6.3.0/node_modules/idb-keyval/dist/index.js
-function promisifyRequest(request) {
-	return new Promise((resolve, reject) => {
-		request.oncomplete = request.onsuccess = () => resolve(request.result);
-		request.onabort = request.onerror = () => reject(request.error);
+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);
 	});
-}
-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;
+	streamOptions = {
+		maxMessageSize: mux.maxMessageSize,
+		timeout
 	};
-	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;
-}
+	let torn = false;
+	return async () => {
+		if (torn) return;
+		torn = true;
+		for (const off of [...live]) {
+			live.delete(off);
+			try {
+				off();
+			} catch {}
+		}
+		await mux.close();
+	};
+};
 /**
-* Get a value by its key.
+* Ports over ONE PIPE OF BYTES — a `MessagePort`, a worker, a WebSocket.
 *
-* @param key
-* @param customStore Method to get a custom store. Use with caution (see the docs).
+* 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 get(key, customStore = defaultGetStore()) {
-	return customStore("readonly", (store) => promisifyRequest(store.get(key)));
+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";
 }
 /**
-* Set a value with a key.
+* For ports whose messages are structured values — a real `MessagePort`, a
+* worker, an iframe.
 *
-* @param key
-* @param value
-* @param customStore Method to get a custom store. Use with caution (see the docs).
+* 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.
 */
-function set(key, value, customStore = defaultGetStore()) {
-	return customStore("readwrite", (store) => {
-		store.put(value, key);
-		return promisifyRequest(store.transaction);
-	});
-}
+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/core/data-calls.ts
-function callChannel(target, callType, params, ...transfers) {
-	return new Promise((resolve, reject) => {
-		const channel = new MessageChannel();
-		channel.port1.onmessage = (ev) => {
-			const { result, error } = ev.data;
-			if (error) reject(deserializeError(error));
-			else resolve(result);
-		};
-		target.postMessage({
-			type: callType,
-			params
-		}, [channel.port2, ...transfers]);
+//#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
 	});
-}
-function handleChannelCalls(target, callType, handler) {
-	const listener = async (event) => {
-		if (!event.data || event.data.type !== callType) return;
-		const [port, ...transfers] = event.ports ?? [];
-		const response = {};
+	return trackedLink((request) => fetchOverDuplex(call, request), async () => {
 		try {
-			response.result = await handler(event, event.data.params, ...transfers);
-		} catch (error) {
-			response.error = serializeError(error);
-		}
-		port?.postMessage(response);
-	};
-	target.addEventListener("message", listener);
-	target.start?.();
-	return () => target.removeEventListener("message", listener);
+			port.postMessage({ type: LINK_CLOSE });
+		} catch {}
+		await close();
+	});
 }
-//#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.
+* 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.
 */
-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);
-		});
-	});
+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;
 }
-//#endregion
-//#region src/core/registry.ts
-function newRegistry(onError = console.error) {
-	let counter = 0;
-	const registrations = {};
-	const register = (action) => {
-		const id = counter++;
-		const fn = Object.assign((skip) => {
+/**
+* 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 {
-				delete registrations[id];
-				return skip ? void 0 : action();
+				response = await Promise.race([send(request), lost]);
 			} catch (error) {
-				onError(error);
+				finish();
+				throw lostReason ?? error;
 			}
-		}, { action });
-		registrations[id] = fn;
-		return fn;
-	};
-	const unregister = (action) => {
-		for (const r of Object.values(registrations)) if (r.action === action) r(true);
-	};
-	const clear = () => {
-		for (const r of Object.values(registrations)) r();
+			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 {}
+		}
 	};
-	return Object.assign([
-		register,
-		clear,
-		unregister
-	], {
-		register,
-		clear,
-		unregister
+}
+/**
+* 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/core/service-worker-control.ts
+//#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()}`;
+}
 /**
-* How long, by default, the page waits for its ServiceWorker to activate and
-* to take control before giving up. Generous: a first install downloads and
-* evaluates the worker script, which on a slow link takes seconds.
+* 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.
 */
-const DEFAULT_SERVICE_WORKER_TIMEOUT = 3e4;
+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;
+}
 /**
-* How long the page waits for `controllerchange` once the worker has
-* answered the `CLAIM` request. `clients.claim()` resolves only after the
-* browser has queued that event, so this is a grace period for delivery, not
-* a second budget.
+* 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`.
 */
-const CLAIM_GRACE_MS = 1e3;
-/** Channel call a page sends to ask its ServiceWorker to `clients.claim()` it. */
-const CLAIM_CALL = "CLAIM";
+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();
+}
 /**
-* Why a page could not get a working ServiceWorker. `reason` says which wait
-* failed; check it (or `name`) rather than `instanceof`, because each of this
-* package's bundles carries its own copy of this class.
+* 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.
 */
-var ServiceWorkerControlError = class extends Error {
-	reason;
-	constructor(reason, message) {
-		super(message);
-		this.name = "ServiceWorkerControlError";
-		this.reason = reason;
+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
 /**
-* Resolves with the registration's worker once it is `activated`. Rejects
-* with a `ServiceWorkerControlError` (`reason: "activation-timeout"`) if that
-* takes longer than `timeout` — an install that throws or never finishes
-* would otherwise leave the caller waiting forever.
+* 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.
 */
-async function awaitActiveServiceWorker(registration, { timeout = DEFAULT_SERVICE_WORKER_TIMEOUT } = {}) {
-	return await withDeadline(Date.now() + timeout, waitForActivated(registration), () => {
-		const worker = registration.installing ?? registration.waiting ?? registration.active;
-		return new ServiceWorkerControlError("activation-timeout", `ServiceWorker ${scriptUrl(worker)} (scope ${registration.scope}) did not activate within ${timeout} ms` + (worker ? `; it is "${worker.state}"` : "") + ". Check the worker script for errors during install (DevTools → Application → Service Workers), or raise the `timeout` option.");
-	});
+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/link/errors.ts
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
 }
+//#endregion
+//#region src/ws/frames.ts
 /**
-* Resolves with the ServiceWorker that controls this page, once `registration`
-* has an activated worker and the page is controlled by it.
+* The wire protocol of a WebSocket carried over a `MessagePort`.
 *
-* A page can stay uncontrolled while its worker is active, and then no
-* `controllerchange` ever fires on its own:
-* - a hard reload (Ctrl+Shift+R) bypasses the worker for that load, and the
-*   worker's `clients.claim()` already ran when it activated;
-* - Firefox can leave a page loaded while the worker is running uncontrolled.
+* 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:
 *
-* So when the page is uncontrolled, this asks the active worker to claim it
-* again (a `CLAIM` channel call — this package's workers answer it) and waits
-* for `controllerchange`. Every wait is bounded by `timeout`. If control never
-* comes it reloads once (`reloadIfUncontrolled`) or rejects with a
-* `ServiceWorkerControlError` (`reason: "uncontrolled"`) that says what
-* happened and what to do.
+* - `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.
 */
-async function awaitServiceWorkerControl(registration, { timeout = DEFAULT_SERVICE_WORKER_TIMEOUT, reloadIfUncontrolled = false, container = navigator.serviceWorker } = {}) {
-	const deadline = Date.now() + timeout;
-	const controlled = waitForController(container);
-	try {
-		const active = await awaitActiveServiceWorker(registration, { timeout });
-		let controller = container.controller;
-		if (!controller) controller = await withDeadline(deadline, (async () => {
-			await Promise.race([callChannel(active, CLAIM_CALL, {}), controlled.promise]);
-			return await Promise.race([controlled.promise, delay(CLAIM_GRACE_MS, null)]);
-		})(), () => null);
-		if (controller) {
-			forgetReload(registration);
-			return controller;
+/** 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
+			};
 		}
-		if (reloadIfUncontrolled && markReload(registration)) {
-			location.reload();
-			return await new Promise(() => {});
+		case "q": return { t: "q" };
+		case "a": {
+			const n = frame.n;
+			return typeof n === "number" && n >= 0 ? {
+				t: "a",
+				n
+			} : void 0;
 		}
-		forgetReload(registration);
-		throw new ServiceWorkerControlError("uncontrolled", `This page is not controlled by its ServiceWorker ${scriptUrl(active)} (scope ${registration.scope}), although the worker is active, and the worker did not take control when asked (clients.claim()) within ${timeout} ms. This happens after a hard reload (Ctrl+Shift+R / Cmd+Shift+R), which bypasses ServiceWorkers for that load, and in Firefox for some pages opened while the worker was already running. Requests from this page would not reach the worker. Reload the page normally, pass \`reloadIfUncontrolled: true\` to do that automatically, check that the page is inside the worker's scope, and that the worker answers the "${CLAIM_CALL}" request (this package's workers do).`);
-	} finally {
-		controlled.cancel();
+		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;
 }
 /**
-* ServiceWorker side: answers the page's `CLAIM` request with
-* `clients.claim()`, which takes over every uncontrolled client in scope.
-* Returns a function that stops answering.
+* A `CloseEvent` for runtimes that have none: Node 22 has `Event` and
+* `MessageEvent` as globals, but not `CloseEvent`.
 */
-function handleClaimRequests(self) {
-	return handleChannelCalls(self, CLAIM_CALL, (event) => {
-		const claimed = self.clients.claim().then(() => true);
-		event.waitUntil?.(claimed);
-		return claimed;
-	});
+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);
 }
-function waitForActivated(registration) {
-	return new Promise((resolve) => {
-		const watched = /* @__PURE__ */ new Set();
-		const check = () => {
-			const active = registration.active;
-			if (active?.state === "activated") {
-				registration.removeEventListener("updatefound", watch);
-				for (const worker of watched) worker.removeEventListener("statechange", check);
-				resolve(active);
-				return;
-			}
-			watch();
+/**
+* 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);
 		};
-		function watch() {
-			for (const worker of [
-				registration.installing,
-				registration.waiting,
-				registration.active
-			]) {
-				if (!worker || watched.has(worker)) continue;
-				watched.add(worker);
-				worker.addEventListener("statechange", check);
-			}
+	}
+	_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;
 		}
-		registration.addEventListener("updatefound", watch);
-		check();
-	});
-}
-function waitForController(container) {
-	let cancel = () => {};
-	return {
-		promise: new Promise((resolve) => {
-			const onChange = () => {
-				if (!container.controller) 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/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/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/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();
+		channel.port1.onmessage = (ev) => {
+			const { result, error } = ev.data;
+			if (error) reject(deserializeError(error));
+			else resolve(result);
+		};
+		target.postMessage({
+			type: callType,
+			params
+		}, [channel.port2, ...transfers]);
+	});
+}
+function handleChannelCalls(target, callType, handler) {
+	const listener = async (event) => {
+		if (!event.data || event.data.type !== callType) return;
+		const [port, ...transfers] = event.ports ?? [];
+		const response = {};
+		let transfer = [];
+		try {
+			const result = await handler(event, 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);
+}
+/**
+* `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/service-worker-control.ts
+/**
+* How long, by default, the page waits for its ServiceWorker to activate and
+* to take control before giving up. Generous: a first install downloads and
+* evaluates the worker script, which on a slow link takes seconds.
+*/
+const DEFAULT_SERVICE_WORKER_TIMEOUT = 3e4;
+/**
+* How long the page waits for `controllerchange` once the worker has
+* answered the `CLAIM` request. `clients.claim()` resolves only after the
+* browser has queued that event, so this is a grace period for delivery, not
+* a second budget.
+*/
+const CLAIM_GRACE_MS = 1e3;
+/** Channel call a page sends to ask its ServiceWorker to `clients.claim()` it. */
+const CLAIM_CALL = "CLAIM";
+/**
+* Why a page could not get a working ServiceWorker. `reason` says which wait
+* failed; check it (or `name`) rather than `instanceof`, because each of this
+* package's bundles carries its own copy of this class.
+*/
+var ServiceWorkerControlError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "ServiceWorkerControlError";
+		this.reason = reason;
+	}
+};
+/**
+* Resolves with the registration's worker once it is `activated`. Rejects
+* with a `ServiceWorkerControlError` (`reason: "activation-timeout"`) if that
+* takes longer than `timeout` — an install that throws or never finishes
+* would otherwise leave the caller waiting forever.
+*/
+async function awaitActiveServiceWorker(registration, { timeout = DEFAULT_SERVICE_WORKER_TIMEOUT } = {}) {
+	return await withDeadline(Date.now() + timeout, waitForActivated(registration), () => {
+		const worker = registration.installing ?? registration.waiting ?? registration.active;
+		return new ServiceWorkerControlError("activation-timeout", `ServiceWorker ${scriptUrl(worker)} (scope ${registration.scope}) did not activate within ${timeout} ms` + (worker ? `; it is "${worker.state}"` : "") + ". Check the worker script for errors during install (DevTools → Application → Service Workers), or raise the `timeout` option.");
+	});
+}
+/**
+* Resolves with the ServiceWorker that controls this page, once `registration`
+* has an activated worker and the page is controlled by it.
+*
+* A page can stay uncontrolled while its worker is active, and then no
+* `controllerchange` ever fires on its own:
+* - a hard reload (Ctrl+Shift+R) bypasses the worker for that load, and the
+*   worker's `clients.claim()` already ran when it activated;
+* - Firefox can leave a page loaded while the worker is running uncontrolled.
+*
+* So when the page is uncontrolled, this asks the active worker to claim it
+* again (a `CLAIM` channel call — this package's workers answer it) and waits
+* for `controllerchange`. Every wait is bounded by `timeout`. If control never
+* comes it reloads once (`reloadIfUncontrolled`) or rejects with a
+* `ServiceWorkerControlError` (`reason: "uncontrolled"`) that says what
+* happened and what to do.
+*/
+async function awaitServiceWorkerControl(registration, { timeout = DEFAULT_SERVICE_WORKER_TIMEOUT, reloadIfUncontrolled = false, container = navigator.serviceWorker } = {}) {
+	const deadline = Date.now() + timeout;
+	const controlled = waitForController(container);
+	try {
+		const active = await awaitActiveServiceWorker(registration, { timeout });
+		let controller = container.controller;
+		if (!controller) controller = await withDeadline(deadline, (async () => {
+			await Promise.race([callChannel(active, CLAIM_CALL, {}), controlled.promise]);
+			return await Promise.race([controlled.promise, delay(CLAIM_GRACE_MS, null)]);
+		})(), () => null);
+		if (controller) {
+			forgetReload(registration);
+			return controller;
+		}
+		if (reloadIfUncontrolled && markReload(registration)) {
+			location.reload();
+			return await new Promise(() => {});
+		}
+		forgetReload(registration);
+		throw new ServiceWorkerControlError("uncontrolled", `This page is not controlled by its ServiceWorker ${scriptUrl(active)} (scope ${registration.scope}), although the worker is active, and the worker did not take control when asked (clients.claim()) within ${timeout} ms. This happens after a hard reload (Ctrl+Shift+R / Cmd+Shift+R), which bypasses ServiceWorkers for that load, and in Firefox for some pages opened while the worker was already running. Requests from this page would not reach the worker. Reload the page normally, pass \`reloadIfUncontrolled: true\` to do that automatically, check that the page is inside the worker's scope, and that the worker answers the "${CLAIM_CALL}" request (this package's workers do).`);
+	} finally {
+		controlled.cancel();
+	}
+}
+/**
+* ServiceWorker side: answers the page's `CLAIM` request with
+* `clients.claim()`, which takes over every uncontrolled client in scope.
+* Returns a function that stops answering.
+*/
+function handleClaimRequests(self) {
+	return handleChannelCalls(self, CLAIM_CALL, (event) => {
+		const claimed = self.clients.claim().then(() => true);
+		event.waitUntil?.(claimed);
+		return claimed;
+	});
+}
+function waitForActivated(registration) {
+	return new Promise((resolve) => {
+		const watched = /* @__PURE__ */ new Set();
+		const check = () => {
+			const active = registration.active;
+			if (active?.state === "activated") {
+				registration.removeEventListener("updatefound", watch);
+				for (const worker of watched) worker.removeEventListener("statechange", check);
+				resolve(active);
+				return;
+			}
+			watch();
+		};
+		function watch() {
+			for (const worker of [
+				registration.installing,
+				registration.waiting,
+				registration.active
+			]) {
+				if (!worker || watched.has(worker)) continue;
+				watched.add(worker);
+				worker.addEventListener("statechange", check);
+			}
+		}
+		registration.addEventListener("updatefound", watch);
+		check();
+	});
+}
+function waitForController(container) {
+	let cancel = () => {};
+	return {
+		promise: new Promise((resolve) => {
+			const onChange = () => {
+				if (!container.controller) return;
 				cancel();
 				resolve(container.controller);
 			};
-			cancel = () => container.removeEventListener("controllerchange", onChange);
-			container.addEventListener("controllerchange", onChange);
-		}),
-		cancel
+			cancel = () => container.removeEventListener("controllerchange", onChange);
+			container.addEventListener("controllerchange", onChange);
+		}),
+		cancel
+	};
+}
+function delay(ms, value) {
+	return new Promise((resolve) => setTimeout(() => resolve(value), ms));
+}
+function scriptUrl(worker) {
+	return worker?.scriptURL ? `"${worker.scriptURL}"` : "(no worker)";
+}
+function reloadKey(registration) {
+	return `webrun-http-browser:reloaded-uncontrolled:${registration.scope}`;
+}
+/** Records the reload about to happen. `false` if one already happened, or if it cannot be recorded. */
+function markReload(registration) {
+	try {
+		const key = reloadKey(registration);
+		if (sessionStorage.getItem(key)) return false;
+		sessionStorage.setItem(key, "1");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function forgetReload(registration) {
+	try {
+		sessionStorage.removeItem(reloadKey(registration));
+	} catch {}
+}
+//#endregion
+//#region src/core/data-channels.ts
+const MESSAGE_TYPE_REQUEST = "REQUEST";
+const MESSAGE_TYPE_RESPONSE = "RESPONSE";
+let __invocationCounter = 0;
+function newInvokationChannel({ port, handler = () => {
+	throw new Error("Handler not implemented");
+}, onError = console.error, newCallId = () => ++__invocationCounter }) {
+	const requests = {};
+	const listener = async (event) => {
+		const data = event.data ?? {};
+		if (data.type === MESSAGE_TYPE_REQUEST) try {
+			const result = await handler(data.request, ...event.ports);
+			const [response, ...transfers] = Array.isArray(result) ? result : result !== void 0 ? [result] : [];
+			port.postMessage({
+				type: MESSAGE_TYPE_RESPONSE,
+				callId: data.callId,
+				response
+			}, transfers);
+		} catch (error) {
+			port.postMessage({
+				type: MESSAGE_TYPE_RESPONSE,
+				callId: data.callId,
+				error: serializeError(error)
+			});
+		}
+		else if (data.type === MESSAGE_TYPE_RESPONSE) {
+			const pending = requests[data.callId];
+			delete requests[data.callId];
+			if (!pending) return;
+			if (data.error) pending.reject(deserializeError(data.error));
+			else pending.resolve(data.response);
+		}
+	};
+	const start = async () => {
+		try {
+			port.addEventListener("message", listener);
+			await port.start?.();
+		} catch (e) {
+			onError(e);
+		}
+	};
+	const close = async () => {
+		try {
+			port.removeEventListener("message", listener);
+			await port.close?.();
+		} catch (e) {
+			onError(e);
+		}
+	};
+	const invoke = (request = {}, ...transfers) => {
+		const callId = newCallId();
+		return new Promise((resolve, reject) => {
+			try {
+				requests[callId] = {
+					resolve,
+					reject
+				};
+				port.postMessage({
+					type: MESSAGE_TYPE_REQUEST,
+					callId,
+					request
+				}, transfers);
+			} catch (error) {
+				delete requests[callId];
+				reject(error);
+			}
+		});
+	};
+	return {
+		start,
+		close,
+		invoke
+	};
+}
+async function* sendStream(communicationPort, input, params = {}) {
+	const messageChannel = new MessageChannel();
+	communicationPort.postMessage({
+		type: "START_CALL",
+		params
+	}, [messageChannel.port2]);
+	const channel = newStreamChannel(messageChannel.port1);
+	let drained = false;
+	try {
+		await channel.start();
+		channel.sendAll(input);
+		yield* channel.recieveAll();
+		drained = true;
+	} finally {
+		if (!drained) channel.cancel();
+		await channel.close();
+	}
+}
+function newStreamChannel(port) {
+	let listeners = [];
+	let iterators = [];
+	const notifyAll = async (data) => {
+		for (const listener of listeners) await listener(data);
+	};
+	/**
+	* Release whatever we are sending. NOT awaited: `.return()` on an async
+	* generator parked awaiting its own source is queued behind that pending
+	* `next()`, so awaiting it here would block the message handler — and the
+	* chunk that would unblock it can only arrive through that same handler.
+	*/
+	const cancelOutgoing = () => {
+		for (const it of [...iterators]) {
+			const iterable = it;
+			Promise.resolve(iterable.return?.()).catch(() => {});
+		}
+	};
+	const channel = newInvokationChannel({
+		port,
+		handler: (data) => {
+			const message = data;
+			if (message?.cancel) {
+				cancelOutgoing();
+				return;
+			}
+			return notifyAll(message);
+		}
+	});
+	const start = () => channel.start();
+	const cancel = () => {
+		channel.invoke({ cancel: true }).catch(() => {});
+	};
+	const close = async () => {
+		await notifyAll({ done: true });
+		for (const it of [...iterators]) await it.return?.();
+		await channel.close();
+	};
+	async function* recieveAll() {
+		yield* recieveIterator((deliver) => {
+			listeners.push(deliver);
+			return () => {
+				listeners = listeners.filter((l) => l !== deliver);
+			};
+		});
+	}
+	async function sendAll(it) {
+		await sendIterator((chunk) => void channel.invoke(chunk), (async function* () {
+			try {
+				iterators.push(it);
+				yield* it;
+			} finally {
+				iterators = iterators.filter((i) => i !== it);
+			}
+		})());
+	}
+	return {
+		start,
+		close,
+		cancel,
+		recieveAll,
+		sendAll
 	};
 }
-function delay(ms, value) {
-	return new Promise((resolve) => setTimeout(() => resolve(value), ms));
+//#endregion
+//#region src/http/http-send-recieve.ts
+async function* httpToIterator(envelopeOrPromise) {
+	const { options, content } = await envelopeOrPromise;
+	yield new TextEncoder().encode(JSON.stringify(options));
+	yield* content;
 }
-function scriptUrl(worker) {
-	return worker?.scriptURL ? `"${worker.scriptURL}"` : "(no worker)";
+async function httpFromIterator(iterable) {
+	const it = (await iterable)[Symbol.asyncIterator]();
+	const { done, value } = await it.next();
+	let options = {};
+	if (!done && value) {
+		const str = new TextDecoder().decode(value);
+		options = JSON.parse(str);
+	}
+	return {
+		options,
+		content: { [Symbol.asyncIterator]() {
+			return it;
+		} }
+	};
 }
-function reloadKey(registration) {
-	return `webrun-http-browser:reloaded-uncontrolled:${registration.scope}`;
+/**
+* Ship a `Request` over a `MessageTarget` and await the `Response`, using this
+* package's own `sendStream` transport.
+*
+* @deprecated Prefer the port stack in `@statewalker/webrun-rpc`: open a port
+* (`multiplexPort` over one pipe, or `transferPortMux` where the platform can
+* transfer a real `MessagePort`), turn it into a `Duplex` with
+* `duplexOverPort`, and drive HTTP over it with `httpFetch` from
+* `@statewalker/webrun-http-streams`.
+*
+* Same caveat as {@link handleHttpRequests}: the transport underneath this
+* helper has no backpressure, no per-stream timeout, and no chunking to a
+* transport's message ceiling. Kept for existing ServiceWorker setups.
+*/
+async function sendHttpRequest(communicationPort, request) {
+	return await newHttpClientStub(async (req) => {
+		return await httpFromIterator(sendStream(communicationPort, httpToIterator(req)));
+	})(request);
 }
-/** Records the reload about to happen. `false` if one already happened, or if it cannot be recorded. */
-function markReload(registration) {
-	try {
-		const key = reloadKey(registration);
-		if (sessionStorage.getItem(key)) return false;
-		sessionStorage.setItem(key, "1");
-		return true;
-	} catch {
-		return false;
+//#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/core/registry.ts
+function newRegistry(onError = console.error) {
+	let counter = 0;
+	const registrations = {};
+	const register = (action) => {
+		const id = counter++;
+		const fn = Object.assign((skip) => {
+			try {
+				delete registrations[id];
+				return skip ? void 0 : action();
+			} catch (error) {
+				onError(error);
+			}
+		}, { action });
+		registrations[id] = fn;
+		return fn;
+	};
+	const unregister = (action) => {
+		for (const r of Object.values(registrations)) if (r.action === action) r(true);
+	};
+	const clear = () => {
+		for (const r of Object.values(registrations)) r();
+	};
+	return Object.assign([
+		register,
+		clear,
+		unregister
+	], {
+		register,
+		clear,
+		unregister
+	});
 }
-function forgetReload(registration) {
+//#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 {
-		sessionStorage.removeItem(reloadKey(registration));
-	} catch {}
+		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
@@ -1980,43 +4683,361 @@ var SwPortDispatcher = class {
 		return index;
 	}
 };
+//#endregion
+//#region src/ws/client.ts
+/** RFC 7230 `token`: what a subprotocol name may be. */
+const TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 /**
-* 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.
+* 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 resolveWorkerUrl(serviceWorkerUrl) {
-	const base = globalThis.location?.href;
+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 {
-		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 });
+		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/sw/http-sw-dispatcher.ts
-var SwHttpAdapter = class extends SwPortHandler {
+//#region src/sw/sw-http-adapter.ts
+/**
+* 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.
+*/
+var SwHttpAdapter = class {
+	options;
 	_handlers = /* @__PURE__ */ new Map();
-	_cleanupRequestChannel;
+	_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) {
-		super({
-			bindPort: () => {},
-			...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 });
 	}
-	async _setCommunicationPort(port) {
-		this._cleanupRequestChannel?.();
-		this._cleanupRequestChannel = handleHttpRequests(port, this._handleHttpRequest.bind(this));
+	get key() {
+		return this.options.key;
 	}
-	async _handleHttpRequest(request) {
-		const requestUrl = request.url;
-		for (const [urlPrefix, handler] of this._handlers) if (requestUrl.indexOf(urlPrefix) === 0) return handler(request);
-		return new Response(null, {
-			status: 404,
-			statusText: "Error 404: Not found"
-		});
+	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
@@ -2035,44 +5056,393 @@ var SwHttpAdapter = class extends SwPortHandler {
 			}
 		};
 	}
+	/**
+	* 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
+		});
+	};
+	/**
+	* 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"
+		});
+	}
 };
-var SwHttpDispatcher = class extends SwPortDispatcher {
-	start() {
-		super.start();
-		this.self.addEventListener("fetch", this._handleFetchEvent.bind(this));
+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);
+		};
 	}
-	_handleFetchEvent(event) {
-		event.respondWith((async () => {
-			const request = event.request;
+	/**
+	* 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;
+	}
+	/** Makes fresh channels and attaches them; the worker gets its ends. */
+	attach() {
+		if (this._detached) return Promise.resolve();
+		this._attaching ??= (async () => {
 			try {
-				const requestUrl = request.url;
-				const rootUrl = this.scope;
-				if (requestUrl.indexOf(rootUrl) === 0) {
-					const key = requestUrl.substring(rootUrl.length).replace(/^\/?([^/]+).*$/, "$1");
-					const channelInfo = await this.loadChannelInfo(key);
-					if (channelInfo?.port) return await sendHttpRequest(channelInfo.port, request);
-					if (this.isClaimedKey(key)) return new Response(null, {
-						status: 404,
-						statusText: "Not Found (no active handler)"
-					});
+				if (this._ownerLock) {
+					const held = await heldLockNames();
+					if (held && !held.has(this._ownerLock)) {
+						this.retire();
+						return;
+					}
 				}
-				return await fetch(request);
-			} catch (error) {
-				console.error(error);
-				return new Response(null, {
-					status: 500,
-					statusText: "Error 500: Internal error"
-				});
+				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 startHttpDispatcher(options) {
-	const dispatcher = new SwHttpDispatcher(options);
-	dispatcher.start();
-	return () => {
-		dispatcher.stop();
+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.`);
+}
+//#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
+	});
+}
+/**
+* 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)`:
+*
+* ```ts
+* // worker.ts
+* const service = serveHttpInWorker(async (request) => new Response("hi"));
+* ```
+*
+* 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 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)();
+		}
 	};
 }
 //#endregion
-export { SwHttpAdapter, SwHttpDispatcher, SwPortDispatcher, SwPortHandler, startHttpDispatcher };
+export { DEFAULT_CLOSE_TIMEOUT_MS, DEFAULT_HEARTBEAT_MS, HANDLER_LOST_MESSAGE, HTTP_LINK_PROTOCOL, HandlerEndpoint, HandlerTable, LinkLostError, PortRendezvous, ROUTER_LOST_MESSAGE, ServerWebSocket, SwHttpAdapter, SwHttpDispatcher, SwPortDispatcher, SwPortHandler, WS_PORT_PROTOCOL_VERSION, WS_VERSION_HEADER, WsCloseEvent, connectHttpLink, connectWebSocketThroughServiceWorker, createWebSocketClass, holdLock, isWebSocketUpgrade, leastInflightRoute, locksAvailable, newLockName, newWebSocketUpgradeRequest, requestedProtocols, serveHttpInWorker, serveHttpLink, serveWebSocketUpgrade, serviceWorkerWebSocketClass, startHttpDispatcher, takePort, takeUpgrade, trackedLink, upgradeWebSocket, watchLock, withHeaders };