@statewalker/webrun-http-browser 0.6.5 → 0.7.1

package/dist/sw-worker.js

@@ -1,4 +1,55 @@
 (function() {
+	//#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 ../webrun-streams/dist/index.js
 	function serializeError(error) {
 		if (error instanceof Error) {
@@ -23,8 +74,6 @@
 		const payload = typeof error === "string" ? { message: error } : error;
 		return Object.assign(new Error(payload.message), payload);
 	}
-	new TextEncoder();
-	new TextDecoder();
 	/**
 	* The newAsyncGenerator function creates async generators from callback-based initialization
 	* functions, providing a bridge between imperative event handling and declarative async
@@ -177,7 +226,6 @@
 			drainQueue();
 		}
 	}
-	new TextEncoder();
 	/**
 	* The iterator ↔ `ReadableStream` boundary.
 	*
@@ -282,6 +330,110 @@
 			});
 		}
 	}
+	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 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);
+	}
+	//#endregion
+	//#region src/core/service-worker-control.ts
+	/** Channel call a page sends to ask its ServiceWorker to `clients.claim()` it. */
+	const CLAIM_CALL = "CLAIM";
+	/**
+	* 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;
+		});
+	}
 	//#endregion
 	//#region ../webrun-http-streams/dist/index.js
 	const CR = 13;
@@ -419,8 +571,8 @@
 	const NEWLINE = 10;
 	/** Mirrors the HTTP/1.1 codec's default `maxHeaderBytes`. */
 	const MAX_ENVELOPE_BYTES = 65536;
-	const encoder$1 = new TextEncoder();
-	const decoder = new TextDecoder();
+	const encoder$1 = /* @__PURE__ */ new TextEncoder();
+	const decoder = /* @__PURE__ */ new TextDecoder();
 	/**
 	* Encode an HTTP envelope plus optional body as one continuous byte stream:
 	*
@@ -674,15 +826,15 @@
 		};
 		return { kind: "none" };
 	}
-	const CRLF = new Uint8Array([13, 10]);
-	const LAST_CHUNK = new Uint8Array([
+	const CRLF = /* @__PURE__ */ new Uint8Array([13, 10]);
+	const LAST_CHUNK = /* @__PURE__ */ new Uint8Array([
 		48,
 		13,
 		10,
 		13,
 		10
 	]);
-	const encoder = new TextEncoder();
+	const encoder = /* @__PURE__ */ new TextEncoder();
 	/**
 	* Chunk sizes are written in HEXADECIMAL — a 21-byte chunk is `15`. Writing
 	* them in decimal is the defect note 15 found in @libp2p/http, and it is the
@@ -987,7 +1139,7 @@
 			decodeResponse: (input, o) => decodeResponse(input, opts, o.method)
 		};
 	}
-	const httpCodec = newHttpCodec();
+	const httpCodec = /* @__PURE__ */ newHttpCodec();
 	/**
 	* Dispatches on byte 0. The formats are self-identifying — a JSON envelope
 	* always begins `{`, which is not a token character and so can never begin an
@@ -1033,11 +1185,245 @@
 			}
 		};
 	}
-	newSniffingCodec({
+	/**
+	* Writes HTTP/1.1; accepts HTTP/1.1 or the legacy JSON envelope. Used whenever
+	* no `codec` option is supplied.
+	*/
+	const defaultCodec = /* @__PURE__ */ newSniffingCodec({
 		write: httpCodec,
 		accept: [httpCodec, jsonEnvelopeCodec]
 	});
 	/**
+	* Makes `target` disposable with `await using`: installs `dispose` as its
+	* `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+	* iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+	* this gives it back. A no-op where the symbol is missing. Kept off the
+	* declared types, which would require consumers to compile with the
+	* `esnext.disposable` lib.
+	*/
+	function asyncDisposable$2(target, dispose) {
+		const asyncDispose = Symbol.asyncDispose;
+		if (asyncDispose && !(asyncDispose in target)) Object.defineProperty(target, asyncDispose, {
+			value: async () => {
+				await dispose();
+			},
+			configurable: true,
+			writable: true
+		});
+		return target;
+	}
+	/** 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 { signal } = options;
+		if (signal?.aborted) throw abortReason$1(signal);
+		const output = call(codec.encodeRequest(env, body));
+		let released;
+		const release = () => {
+			released ??= (async () => {
+				try {
+					await output.return?.(void 0);
+				} catch {}
+			})();
+			return released;
+		};
+		let finished = false;
+		const finish = () => {
+			if (finished || released) return;
+			finished = true;
+			if (signal?.aborted) {
+				release();
+				return;
+			}
+			const onAbort = () => void release();
+			signal?.addEventListener("abort", onAbort, { once: true });
+			drain(output).finally(() => signal?.removeEventListener("abort", onAbort));
+		};
+		let decoded;
+		try {
+			decoded = await untilAborted(codec.decodeResponse(output, { method: env.method }), signal);
+		} catch (error) {
+			if (signal?.aborted) release();
+			else await release();
+			throw error;
+		}
+		const result = {
+			envelope: decoded.envelope,
+			body: releasingOnExit(decoded.body, finish, release),
+			release,
+			finish
+		};
+		await throwIfPeerError(result, output);
+		return result;
+	}
+	/** `promise`, rejected with the signal's reason if it aborts first. */
+	function untilAborted(promise, signal) {
+		if (!signal) return promise;
+		return new Promise((resolve, reject) => {
+			const onAbort = () => reject(abortReason$1(signal));
+			if (signal.aborted) return onAbort();
+			signal.addEventListener("abort", onAbort, { once: true });
+			promise.then((value) => {
+				signal.removeEventListener("abort", onAbort);
+				resolve(value);
+			}, (error) => {
+				signal.removeEventListener("abort", onAbort);
+				reject(error);
+			});
+		});
+	}
+	/** The signal's reason as an `Error` (`AbortError` when it gave none). */
+	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;
+	}
+	/**
+	* `body`, ending the call however it is left: read to its end, or left early.
+	*
+	* The body the codec hands back is a generator of its own over a `ByteReader`,
+	* and its ending never reaches the call's `output` (see `throwIfPeerError` for
+	* why the codec must not do that itself). A caller that stopped reading — an
+	* aborted `fetch`, a cancelled response stream — left the peer's producer
+	* parked forever; and one that read the body to its end left the call itself
+	* open, which on a multiplexed transport is one port per exchange until the
+	* multiplexer refuses to open more (`maxPorts`).
+	*
+	* Left early, the call is abandoned (`.return()`): the peer's producer is
+	* released. Read to its end, the call is not cut short but read to ITS end, in
+	* the background: the peer ends it once its side of the exchange is over,
+	* which may be later than the response — a handler that answered before it
+	* read the request body is still receiving it (`HttpDataHandlerResult.settled`),
+	* and abandoning the call would abort that upload.
+	*/
+	async function* releasingOnExit(body, finish, release) {
+		let completed = false;
+		try {
+			yield* body;
+			completed = true;
+		} finally {
+			if (completed) finish();
+			else await release();
+		}
+	}
+	/** Reads `output` to its end, discarding what is left, ignoring a failure. */
+	async function drain(output) {
+		try {
+			for (let r = await output.next(); !r.done; r = await output.next());
+		} catch {}
+	}
+	/**
+	* 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;
+				await result.settled?.();
+			} 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
 	* carry a client and a server direction that must agree on the answer, so the
@@ -1080,6 +1466,31 @@
 	function supportsRequestStreams() {
 		return typeof Request === "function" && Object.getOwnPropertyDescriptor(Request.prototype, "body") != null;
 	}
+	/**
+	* Drain a body iterable into one contiguous buffer. Only the fallbacks need it.
+	* Allocates its own buffer rather than reusing `bytes.ts`'s `concatChunks`,
+	* which passes a single chunk straight through: that chunk is a view onto the
+	* decoder's own read buffer, and the result here is handed to `new Request` and
+	* outlives the decode. The allocation is also what makes it a
+	* `Uint8Array<ArrayBuffer>`, which `BodyInit` accepts and the looser
+	* `Uint8Array<ArrayBufferLike>` does not.
+	*/
+	async function collectBytes(source) {
+		const parts = [];
+		let total = 0;
+		for await (const chunk of source) {
+			if (chunk.byteLength === 0) continue;
+			parts.push(chunk);
+			total += chunk.byteLength;
+		}
+		const out = new Uint8Array(total);
+		let offset = 0;
+		for (const part of parts) {
+			out.set(part, offset);
+			offset += part.byteLength;
+		}
+		return out;
+	}
 	const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
 		101,
 		103,
@@ -1142,51 +1553,292 @@
 			return new Response(toReadableStream(result.content[Symbol.asyncIterator]()), responseOptions);
 		};
 	}
-	//#endregion
-	//#region src/core/data-channels.ts
-	const MESSAGE_TYPE_REQUEST = "REQUEST";
-	const MESSAGE_TYPE_RESPONSE = "RESPONSE";
-	let __invocationCounter = 0;
-	function newInvokationChannel({ port, handler = () => {
-		throw new Error("Handler not implemented");
-	}, onError = console.error, newCallId = () => ++__invocationCounter }) {
-		const requests = {};
-		const listener = async (event) => {
-			const data = event.data ?? {};
-			if (data.type === MESSAGE_TYPE_REQUEST) try {
-				const result = await handler(data.request, ...event.ports);
-				const [response, ...transfers] = Array.isArray(result) ? result : result !== void 0 ? [result] : [];
-				port.postMessage({
-					type: MESSAGE_TYPE_RESPONSE,
-					callId: data.callId,
-					response
-				}, transfers);
-			} catch (error) {
-				port.postMessage({
-					type: MESSAGE_TYPE_RESPONSE,
-					callId: data.callId,
-					error: serializeError(error)
-				});
-			}
-			else if (data.type === MESSAGE_TYPE_RESPONSE) {
-				const pending = requests[data.callId];
-				delete requests[data.callId];
-				if (!pending) return;
-				if (data.error) pending.reject(deserializeError(data.error));
-				else pending.resolve(data.response);
+	/**
+	* 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;
 			}
-		};
-		const start = async () => {
+		} finally {
+			if (!consumed) try {
+				await reader.cancel();
+			} catch {}
 			try {
-				port.addEventListener("message", listener);
-				await port.start?.();
-			} catch (e) {
-				onError(e);
+				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)
 		};
-		const close = async () => {
-			try {
-				port.removeEventListener("message", listener);
+		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, finish } = await httpFetch(call, env, body, {
+			...options,
+			signal: request.signal ?? void 0
+		});
+		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)) {
+			if (finish) finish();
+			else 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 serveFetchOverDuplex(handler, options = {}) {
+		return httpServe(async (env, body) => {
+			const reqInit = {
+				method: env.method,
+				headers: forwardableHeaders(env.headers)
+			};
+			let upload;
+			if (env.method !== "GET" && env.method !== "HEAD") {
+				if (supportsRequestStreams()) {
+					upload = trackingEnd(body);
+					reqInit.body = asyncIterableToReadable(upload.source);
+					reqInit.duplex = "half";
+				} else reqInit.body = await collectBytes(body);
+			}
+			const request = new Request(env.url, reqInit);
+			const response = await handler(request);
+			const settled = async () => {
+				if (!upload) return;
+				if (!request.bodyUsed && !request.body?.locked) request.body?.cancel().catch(() => {});
+				await upload.settle(options.requestIdleMs ?? 3e4);
+			};
+			const respEnv = {
+				status: response.status,
+				statusText: response.statusText,
+				headers: headersToArray(response.headers)
+			};
+			if (env.method === "HEAD" || env.method === "OPTIONS" || NULL_BODY_STATUSES.has(response.status)) {
+				await response.body?.cancel();
+				return {
+					envelope: respEnv,
+					body: void 0,
+					settled
+				};
+			}
+			return {
+				envelope: respEnv,
+				body: response.body ? readableToAsyncIterable(response.body) : void 0,
+				release: () => response.body?.cancel(),
+				settled
+			};
+		}, options);
+	}
+	/**
+	* `source`, and `settle(idleMs)`: resolves once it is done — read to its end,
+	* failed, or abandoned (`return()` included before the first `next()`, which a
+	* generator's `finally` would not see) — or once nobody has asked it for a
+	* chunk for `idleMs`, in which case it is abandoned: later reads fail.
+	*
+	* Idle counts only while no `next()` is pending: a reader waiting for a slow
+	* sender is still reading.
+	*/
+	function trackingEnd(source) {
+		let end = () => {};
+		let isEnded = false;
+		const ended = new Promise((resolve) => {
+			end = () => {
+				isEnded = true;
+				resolve();
+			};
+		});
+		let abandoned;
+		let pending = 0;
+		let idleSince = Date.now();
+		const it = source[Symbol.asyncIterator]();
+		const abandon = (reason) => {
+			abandoned ??= reason;
+			end();
+			Promise.resolve(it.return?.(void 0)).catch(() => {});
+		};
+		const tracked = {
+			[Symbol.asyncIterator]() {
+				return tracked;
+			},
+			async next() {
+				if (abandoned) throw abandoned;
+				pending++;
+				try {
+					const r = await it.next();
+					if (r.done) end();
+					return r;
+				} catch (error) {
+					end();
+					throw error;
+				} finally {
+					if (--pending === 0) idleSince = Date.now();
+				}
+			},
+			async return(value) {
+				end();
+				try {
+					await it.return?.(value);
+				} catch {}
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+		};
+		asyncDisposable$2(tracked, () => tracked.return?.() ?? Promise.resolve());
+		const settle = (idleMs) => {
+			if (isEnded || !Number.isFinite(idleMs)) return ended;
+			return new Promise((resolve) => {
+				let timer;
+				const check = () => {
+					if (isEnded) return resolve();
+					const idle = pending === 0 ? Date.now() - idleSince : 0;
+					if (idle >= idleMs) {
+						abandon(/* @__PURE__ */ new Error(`webrun-http-streams: the request body was left unread for ${idleMs} ms after the response; abandoned`));
+						return resolve();
+					}
+					timer = setTimeout(check, Math.max(1, Math.min(idleMs - idle, 1e3)));
+					timer.unref?.();
+				};
+				ended.then(() => {
+					clearTimeout(timer);
+					resolve();
+				});
+				check();
+			});
+		};
+		return {
+			source: tracked,
+			settle
+		};
+	}
+	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;
+		}
+	}
+	//#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);
@@ -1341,266 +1993,1751 @@
 		})(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);
+	//#region src/link/errors.ts
+	function errorMessage(error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+	//#endregion
+	//#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;
+			}
+			if (Number.isFinite(timeout) && timeout > 0) timerId = setTimeout(() => reject(/* @__PURE__ */ new Error(`Call timeout. CallId: "${callId}".`)), timeout);
+			onMessage = (event) => {
+				const data = event.data;
+				if (!data) return;
+				if (data.channelName !== channelName) return;
+				if (data.callId !== callId) return;
+				if (data.type === "response:error") reject(deserializeError(data.error));
+				else if (data.type === "response:result") resolve(data.result);
+			};
+			port.addEventListener("message", onMessage);
+			if (combinedSignal) {
+				onAbort = () => reject(abortReason(combinedSignal));
+				combinedSignal.addEventListener("abort", onAbort, { once: true });
+			}
 		});
+		promise.catch(() => {}).finally(() => {
+			if (timerId !== void 0) clearTimeout(timerId);
+			if (onMessage) port.removeEventListener("message", onMessage);
+			if (onAbort && combinedSignal) combinedSignal.removeEventListener("abort", onAbort);
+		});
+		port.postMessage({
+			type: "request",
+			channelName,
+			callId,
+			params
+		});
+		return promise;
 	}
-	function 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;
+	function abortReason(signal) {
+		const reason = signal.reason;
+		if (reason instanceof Error) return reason;
+		const err = new Error(reason === void 0 ? "Aborted" : String(reason));
+		err.name = "AbortError";
+		return err;
+	}
+	function combineSignals(...signals) {
+		const live = signals.filter((s) => s !== void 0);
+		if (live.length === 0) return void 0;
+		if (live.length === 1) return live[0];
+		return AbortSignal.any(live);
+	}
+	/**
+	* Installs `handler` as the server side of a `callPort` / `listenPort`
+	* request/response pair on `port`.
+	*
+	* Returns a cleanup function that removes the listener.
+	*/
+	function listenPort(port, handler, { channelName = "", log = () => {} } = {}) {
+		const onMessage = async (event) => {
+			const data = event.data;
+			if (!data || data.channelName !== channelName || data.type !== "request") return;
+			const { callId, params } = data;
+			log("[listenPort]", {
+				channelName,
+				callId,
+				params
+			});
+			let result;
+			let error;
+			let type;
+			try {
+				result = await handler(params);
+				type = "response:result";
+			} catch (e) {
+				error = serializeError(e);
+				type = "response:error";
+			}
+			port.postMessage({
+				callId,
+				channelName,
+				type,
+				result,
+				error
 			});
-			return dbp;
 		};
-		return (txMode, callback) => getDB().then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
+		port.addEventListener("message", onMessage);
+		return () => port.removeEventListener("message", onMessage);
 	}
-	let defaultGetStoreFunc;
-	function defaultGetStore() {
-		if (!defaultGetStoreFunc) defaultGetStoreFunc = createStore("keyval-store", "keyval");
-		return defaultGetStoreFunc;
+	/**
+	* 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 {
+			while (true) {
+				const r = await iter.next();
+				if (r.done) return;
+				if (signal.aborted) return;
+				yield r.value;
+			}
+		} finally {
+			signal.removeEventListener("abort", onAbort);
+		}
 	}
 	/**
-	* Get a value by its key.
+	* Makes `target` disposable with `await using`: installs `dispose` as its
+	* `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+	* iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+	* this gives it back. A no-op where the symbol is missing. Kept off the
+	* declared types, which would require consumers to compile with the
+	* `esnext.disposable` lib.
+	*/
+	function asyncDisposable$1(target, dispose) {
+		const asyncDispose = Symbol.asyncDispose;
+		if (asyncDispose && !(asyncDispose in target)) Object.defineProperty(target, asyncDispose, {
+			value: async () => {
+				await dispose();
+			},
+			configurable: true,
+			writable: true
+		});
+		return target;
+	}
+	/**
+	* `gen`, except that `return()` and `throw()` take effect at once.
 	*
-	* @param key
-	* @param customStore Method to get a custom store. Use with caution (see the docs).
+	* On an async generator both are queued behind a `next()` that is still
+	* pending: a consumer that gives up on a stream while it waits for the peer's
+	* next chunk — an aborted fetch whose response head has not come, say — cannot
+	* end it until that chunk arrives, which for a peer that never answers is
+	* never. The stream's `finally` (which closes its port and tells the peer)
+	* then never runs, and on a multiplexer the port is kept for good.
+	*
+	* So `abandon` runs first, synchronously: it must make the pending `next()`
+	* settle (abort the stream), which then resolves done, after which the
+	* generator's own `return()` / `throw()` proceeds as usual. On a generator
+	* suspended at a `yield` it is the same ending, a step earlier. `abandon` runs once, whichever comes first.
 	*/
-	function get(key, customStore = defaultGetStore()) {
-		return customStore("readonly", (store) => promisifyRequest(store.get(key)));
+	function returningAtOnce(gen, abandon) {
+		let abandoned = false;
+		const giveUp = (reason) => {
+			if (abandoned) return;
+			abandoned = true;
+			abandon(reason);
+		};
+		const wrapped = {
+			next: (...args) => gen.next(...args).catch((error) => {
+				if (abandoned) return {
+					done: true,
+					value: void 0
+				};
+				throw error;
+			}),
+			return(value) {
+				giveUp();
+				return gen.return(value);
+			},
+			throw(error) {
+				giveUp(error);
+				return gen.throw(error);
+			},
+			[Symbol.asyncIterator]() {
+				return wrapped;
+			}
+		};
+		return asyncDisposable$1(wrapped, () => wrapped.return(void 0));
 	}
 	/**
-	* Set a value with a key.
+	* The `type` of the out-of-band notice a side posts when it abandons a stream.
 	*
-	* @param key
-	* @param value
-	* @param customStore Method to get a custom store. Use with caution (see the docs).
+	* 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.
 	*/
-	function set(key, value, customStore = defaultGetStore()) {
-		return customStore("readwrite", (store) => {
-			store.put(value, key);
-			return promisifyRequest(store.transaction);
-		});
+	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);
 	}
-	//#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]);
+	/**
+	* 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();
 		});
 	}
-	function handleChannelCalls(target, callType, handler) {
-		const listener = async (event) => {
-			if (!event.data || event.data.type !== callType) return;
-			const [port, ...transfers] = event.ports ?? [];
-			const response = {};
+	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 returningAtOnce((async function* () {
 			try {
-				response.result = await handler(event, event.data.params, ...transfers);
-			} catch (error) {
-				response.error = serializeError(error);
+				yield* inbound.stream;
+			} finally {
+				if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: the caller abandoned the stream"));
+				notice.post();
+				notice.stop();
+				clock.stop();
+				inbound.stop();
+				await pump.catch(() => {});
+				try {
+					await port.close?.();
+				} catch {}
 			}
-			port?.postMessage(response);
-		};
-		target.addEventListener("message", listener);
-		target.start?.();
-		return () => target.removeEventListener("message", listener);
+		})(), () => {
+			if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: the caller abandoned the stream"));
+		});
 	}
-	//#endregion
-	//#region src/core/service-worker-control.ts
-	/** Channel call a page sends to ask its ServiceWorker to `clients.claim()` it. */
-	const CLAIM_CALL = "CLAIM";
 	/**
-	* 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.
+	* 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 handleClaimRequests(self) {
-		return handleChannelCalls(self, CLAIM_CALL, (event) => {
-			const claimed = self.clients.claim().then(() => true);
-			event.waitUntil?.(claimed);
-			return claimed;
-		});
+	function installAbortNotice(port, controller) {
+		const onMessage = (event) => {
+			const data = event.data;
+			if (!data || data.type !== "webrun-rpc:stream-abort") return;
+			if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: the peer abandoned the stream"));
+		};
+		port.addEventListener("message", onMessage);
+		let posted = false;
+		return {
+			post() {
+				if (posted) return;
+				posted = true;
+				try {
+					port.postMessage({ type: STREAM_ABORT });
+				} catch {}
+			},
+			stop() {
+				port.removeEventListener("message", onMessage);
+			}
+		};
 	}
-	//#endregion
-	//#region src/sw/sw-dispatcher.ts
 	/**
-	* ServiceWorker-side counterpart: maintains an index of connected clients keyed by
-	* clientId, persisted in IndexedDB so it can reclaim ports across SW restarts.
+	* 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.
 	*/
-	var SwPortDispatcher = class {
-		self;
-		log;
-		handlersIndex = /* @__PURE__ */ new Map();
-		/**
-		* Set of keys that were registered at some point on this SW (sticky —
-		* survives client closures + SW wake-ups via IndexedDB). Lets the fetch
-		* handler distinguish "site URL whose owner is gone → 404" from
-		* "unknown URL under scope → pass through to the network".
-		*/
-		claimedKeys = /* @__PURE__ */ new Set();
-		_cleanup;
-		_activationPromise;
-		constructor({ self, log = () => {} }) {
-			this.self = self;
-			this.log = log;
+	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;
 		}
-		get scope() {
-			return `${new URL("./", this.self.location.href)}`;
+		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;
+		});
+		let aborted = false;
+		let abortReason;
+		const ready = () => deliver || finished ? Promise.resolve() : new Promise((r) => waiting.push(r));
+		const wake = () => {
+			for (const r of waiting.splice(0)) r();
+		};
+		const off = listenPort(port, async ({ done, value, error }) => {
+			touch();
+			if (poison) throw poison;
+			if (outstanding) {
+				poison = /* @__PURE__ */ new Error("webrun-rpc: peer sent a second unconfirmed chunk; the stream port is closed");
+				controller.abort(poison);
+				setTimeout(() => {
+					try {
+						port.close?.();
+					} catch {}
+				}, 0);
+				throw poison;
+			}
+			outstanding = true;
+			try {
+				await ready();
+				if (finished) throw poison ?? /* @__PURE__ */ new Error("webrun-rpc: the stream is closed");
+				await deliver?.({
+					done,
+					value,
+					error: error ? deserializeError(error) : void 0
+				});
+			} finally {
+				outstanding = false;
+			}
+			if (done) resolveEnded();
+		}, { channelName });
+		const detach = () => {
+			finished = true;
+			wake();
+			off();
+			controller.signal.removeEventListener("abort", onAbort);
+			resolveEnded();
+		};
+		const onAbort = () => {
+			aborted = true;
+			abortReason = controller.signal.reason;
+			finished = true;
+			wake();
+			deliver?.({
+				done: true,
+				error: abortReason
+			});
+			resolveEnded();
+		};
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+		return {
+			stream: recieveIterator((d) => {
+				if (aborted) {
+					d({
+						done: true,
+						error: abortReason
+					});
+					return detach;
+				}
+				deliver = d;
+				wake();
+				return detach;
+			}),
+			stop: detach,
+			ended
+		};
+	}
+	/**
+	* The sending half of one direction: one `callPort` per chunk, one call
+	* outstanding at a time (spec D11/D12), with no per-chunk deadline (spec D8).
+	*/
+	async function sendChunks(port, channelName, output, { maxMessageSize, log }, signal, touch) {
+		const stream = throughAbort(maxMessageSize ? toChunks(maxMessageSize)(output) : output, signal);
+		try {
+			await sendIterator(async ({ done, value, error }) => {
+				if (signal.aborted) return;
+				const chunk = {
+					done,
+					value,
+					error: error === void 0 ? void 0 : serializeError(error)
+				};
+				log?.("[duplexOverPort] send", {
+					channelName,
+					done,
+					size: value?.byteLength
+				});
+				await callPort(port, chunk, {
+					channelName,
+					timeout: NO_TIMEOUT,
+					signal
+				});
+				touch();
+			}, stream);
+		} catch (err) {
+			if (signal.aborted) return;
+			throw err;
 		}
-		/**
-		* Look up the active channel for a key. Returns `undefined` when there
-		* is no registration (or the registering client has gone away — stale
-		* entries are pruned in place).
-		*/
-		async loadChannelInfo(key) {
-			await this._checkActivation();
-			for (const channelInfo of this.handlersIndex.values()) {
-				if (channelInfo.key !== key) continue;
-				const clientId = channelInfo.clientId;
-				if (!clientId) continue;
-				if (!await this.self.clients.get(clientId)) {
-					this.handlersIndex.delete(clientId);
-					continue;
+	}
+	/**
+	* One virtual port.
+	*
+	* `deliver` and `markClosed` are deliberately not on `port`: the consumer holds
+	* only a `MessageTarget`, so it cannot forge inbound traffic or close the port
+	* out from under the multiplexer's bookkeeping.
+	*/
+	function newVirtualPort(send, requestClose) {
+		const listeners = /* @__PURE__ */ new Set();
+		let closed = false;
+		const closing = new AbortController();
+		const abort = (reason) => {
+			if (closing.signal.aborted) return;
+			closing.abort(reason ?? /* @__PURE__ */ new Error("webrun-rpc: the port was closed"));
+		};
+		const port = {
+			addEventListener(_type, listener) {
+				listeners.add(listener);
+			},
+			removeEventListener(_type, listener) {
+				listeners.delete(listener);
+			},
+			postMessage(message, transfer) {
+				if (closed) return;
+				send(message, transfer);
+			},
+			close() {
+				if (closed) return;
+				closed = true;
+				const notify = requestClose;
+				listeners.clear();
+				notify();
+				abort();
+			}
+		};
+		setPortCloseSignal(port, closing.signal);
+		return {
+			port,
+			deliver(payload) {
+				if (closed) return;
+				const event = new MessageEvent("message", { data: payload });
+				for (const listener of [...listeners]) try {
+					listener(event);
+				} catch {}
+			},
+			markClosed(reason) {
+				closed = true;
+				listeners.clear();
+				abort(reason);
+			},
+			isClosed() {
+				return closed;
+			}
+		};
+	}
+	/**
+	* The message of the error that fails the calls still in flight on a
+	* multiplexer when it is closed (`PortMux.close()`).
+	*/
+	const MUX_CLOSED_MESSAGE = "webrun-rpc: the multiplexer was closed";
+	/** Ceiling on concurrently open virtual ports. Bounds the id table only. */
+	const DEFAULT_MAX_PORTS = 1024;
+	/**
+	* The default `PortMux`: emulates multiplexing over a single port.
+	*
+	* A transport that already multiplexes natively supplies its own `PortMux`
+	* instead — this implementation is for transports that offer one pipe.
+	*/
+	function multiplexPort(port, options) {
+		const { codec, onPort, side = "initiator", maxPorts = DEFAULT_MAX_PORTS, maxMessageSize } = options;
+		const open = /* @__PURE__ */ new Map();
+		let nextId = side === "initiator" ? 0 : 1;
+		let muxClosed = false;
+		const post = (envelope, transfer) => {
+			if (muxClosed) return;
+			try {
+				codec.post(port, envelope, transfer);
+			} catch {}
+		};
+		const attach = (id) => {
+			let self;
+			self = newVirtualPort((payload, transfer) => post({
+				type: "message",
+				id,
+				payload
+			}, transfer), (reason) => {
+				post({
+					type: "close",
+					id,
+					reason
+				});
+				open.delete(id);
+				self.markClosed();
+			});
+			open.set(id, self);
+			return self;
+		};
+		const handleEnvelope = (envelope) => {
+			if (muxClosed) return;
+			if (envelope.type === "open") {
+				if (open.has(envelope.id)) return;
+				if (open.size >= maxPorts) {
+					post({
+						type: "close",
+						id: envelope.id,
+						reason: "max-ports"
+					});
+					return;
+				}
+				const handle = attach(envelope.id);
+				let accepted = false;
+				if (onPort) try {
+					accepted = onPort(handle.port, envelope.meta) !== false;
+				} catch {
+					accepted = false;
+				}
+				if (!accepted) {
+					open.delete(envelope.id);
+					handle.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the port was rejected"));
+					post({
+						type: "close",
+						id: envelope.id,
+						reason: "rejected"
+					});
+				}
+				return;
+			}
+			const handle = open.get(envelope.id);
+			if (envelope.type === "message") {
+				if (!handle) return;
+				handle.deliver(envelope.payload);
+				return;
+			}
+			if (!handle) return;
+			open.delete(envelope.id);
+			handle.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the peer closed the port"));
+		};
+		const listener = (event) => {
+			const envelope = codec.read(event);
+			if (envelope) handleEnvelope(envelope);
+		};
+		port.addEventListener("message", listener);
+		port.start?.();
+		return {
+			maxMessageSize,
+			async openPort(meta) {
+				if (muxClosed) throw new Error("webrun-rpc: the multiplexer is closed");
+				if (open.size >= maxPorts) throw new RangeError(`webrun-rpc: maxPorts (${maxPorts}) reached`);
+				while (open.has(nextId)) nextId += 2;
+				const id = nextId;
+				nextId += 2;
+				const handle = attach(id);
+				post({
+					type: "open",
+					id,
+					meta
+				});
+				return handle.port;
+			},
+			async close() {
+				if (muxClosed) return;
+				for (const [id, handle] of [...open]) {
+					post({
+						type: "close",
+						id
+					});
+					open.delete(id);
+					handle.markClosed(/* @__PURE__ */ new Error(MUX_CLOSED_MESSAGE));
 				}
-				return channelInfo;
+				muxClosed = true;
+				port.removeEventListener("message", listener);
+				await port.close?.();
 			}
+		};
+	}
+	/**
+	* Announced with every port this pair opens. Layer 1 never reads `meta` — it is
+	* here so a peer running something else over the same multiplexer can tell a
+	* stream port from whatever else it hands out, and so a packet capture says
+	* what the port is for.
+	*/
+	const STREAM_META = { kind: "stream" };
+	/**
+	* One port source in, one caller `Duplex` out.
+	*
+	* A call is a port: the mux allocates one, `duplexOverPort` runs the single
+	* invocation on it, and closing the stream closes the port. No stream ids, no
+	* framing and no credit accounting live here — the mux owns the first, and
+	* `duplexOverPort` owns the one-chunk window that makes memory bounded.
+	*/
+	const connect = async ({ mux: factory, timeout }) => {
+		const mux = await factory();
+		const streamOptions = {
+			maxMessageSize: mux.maxMessageSize,
+			timeout
+		};
+		const call = (input) => {
+			let stream;
+			let abandoned = false;
+			return returningAtOnce((async function* () {
+				const port = await mux.openPort(STREAM_META);
+				if (abandoned) {
+					await port.close?.();
+					return;
+				}
+				stream = duplexOverPort(port, streamOptions)(input);
+				yield* stream;
+			})(), () => {
+				abandoned = true;
+				stream?.return(void 0).catch(() => {});
+			});
+		};
+		return {
+			call,
+			async close() {
+				await mux.close();
+			}
+		};
+	};
+	/**
+	* One port source in, `handler` serving every call that arrives on it.
+	*
+	* Each inbound port is one invocation, so the factory's `onPort` is the accept
+	* loop: it installs `handler` on the new port and nothing else. The returned
+	* teardown abandons the streams still running *before* dropping the mux, so
+	* the peer's callers reject with "the peer abandoned the stream" instead of
+	* parking forever on a port that has silently gone inert — layer 1's close is
+	* not observable to layer 2, which is why the notice has to be posted
+	* deliberately.
+	*/
+	const serve = async ({ mux: factory, timeout }, handler) => {
+		const live = /* @__PURE__ */ new Set();
+		let streamOptions = { timeout };
+		const mux = await factory((port) => {
+			let off;
+			let finished = false;
+			const tracked = (input) => (async function* () {
+				try {
+					yield* handler(input);
+				} finally {
+					finished = true;
+					if (off) live.delete(off);
+				}
+			})();
+			off = serveDuplexOverPort(port, tracked, streamOptions);
+			if (!finished) live.add(off);
+		});
+		streamOptions = {
+			maxMessageSize: mux.maxMessageSize,
+			timeout
+		};
+		let torn = false;
+		return async () => {
+			if (torn) return;
+			torn = true;
+			for (const off of [...live]) {
+				live.delete(off);
+				try {
+					off();
+				} catch {}
+			}
+			await mux.close();
+		};
+	};
+	/**
+	* Ports over ONE PIPE OF BYTES — a `MessagePort`, a worker, a WebSocket.
+	*
+	* There is no second port to be had, so `multiplexPort`'s id table invents
+	* them. Use this when the transport gives you exactly one channel.
+	*/
+	function overPipe(pipe, options) {
+		return (onPort) => multiplexPort(pipe, {
+			...options,
+			onPort
+		});
+	}
+	function isEnvelope(value) {
+		if (typeof value !== "object" || value === null) return false;
+		const candidate = value;
+		if (typeof candidate.id !== "number") return false;
+		if (!Number.isInteger(candidate.id) || candidate.id < 0) return false;
+		return candidate.type === "open" || candidate.type === "message" || candidate.type === "close";
+	}
+	/**
+	* For ports whose messages are structured values — a real `MessagePort`, a
+	* worker, an iframe.
+	*
+	* Envelopes are posted as-is, so nothing is encoded, `ArrayBuffer`s move
+	* zero-copy through the transfer list, and structured clone does the work the
+	* platform already does well. This is a performance choice only: layer 2 may
+	* not send anything a byte codec could not also carry.
+	*/
+	const structuredCodec = {
+		post(port, envelope, transfer) {
+			if (transfer && transfer.length > 0) port.postMessage(envelope, transfer);
+			else port.postMessage(envelope);
+		},
+		read(event) {
+			return isEnvelope(event.data) ? event.data : void 0;
+		}
+	};
+	//#endregion
+	//#region src/link/async-dispose.ts
+	/**
+	* Makes `target` disposable with `await using`: installs `dispose` as its
+	* `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+	* iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+	* this gives it back. A no-op where the symbol is missing. Kept off the
+	* declared types, which would require consumers to compile with the
+	* `esnext.disposable` lib.
+	*/
+	function asyncDisposable(target, dispose) {
+		const asyncDispose = Symbol.asyncDispose;
+		if (asyncDispose && !(asyncDispose in target)) Object.defineProperty(target, asyncDispose, {
+			value: async () => {
+				await dispose();
+			},
+			configurable: true,
+			writable: true
+		});
+		return target;
+	}
+	//#endregion
+	//#region src/link/http-link.ts
+	/**
+	* The version of the HTTP-over-`MessagePort` protocol this package speaks,
+	* sent in every hand-shake that sets up a link. Version 1 was this package's
+	* own `handleStreams` / `sendStream` (no backpressure); version 2 is
+	* webrun-rpc's `connect` / `serve` over `overPipe` with webrun-http-streams'
+	* `fetchOverDuplex` / `serveFetchOverDuplex`: one port per link, calls
+	* multiplexed on it, each call a stream with a one-chunk window in both
+	* directions, and cancellation that reaches the handler.
+	*/
+	const HTTP_LINK_PROTOCOL = "webrun-http-link/2";
+	/**
+	* Why a request failed when its link went away under it: the far side (the
+	* handler, or the ServiceWorker) was lost. The request may or may not have
+	* been applied.
+	*/
+	var LinkLostError = class extends Error {
+		constructor(message = "The link was lost while this request was in flight") {
+			super(`${message}; it may or may not have been applied.`);
+			this.name = "LinkLostError";
 		}
-		/** Whether `key` has ever been registered on this SW. */
+	};
+	/**
+	* 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, maxPorts } = {}) {
+		const { call, close } = await connect({
+			mux: overPipe(port, {
+				codec: structuredCodec,
+				side: "initiator",
+				maxPorts
+			}),
+			timeout: streamTimeout
+		});
+		return trackedLink((request) => fetchOverDuplex(call, request), async () => {
+			try {
+				port.postMessage({ type: LINK_CLOSE });
+			} catch {}
+			await close();
+		});
+	}
+	/**
+	* Serves `handler` on the answering end of a link. Resolves with a teardown
+	* that abandons the requests still running (their handlers see the
+	* cancellation) and releases the port.
+	*/
+	async function serveHttpLink(port, handler, { streamTimeout, maxPorts, requestIdleMs } = {}) {
+		const teardown = await serve({
+			mux: overPipe(port, {
+				codec: structuredCodec,
+				side: "responder",
+				maxPorts
+			}),
+			timeout: streamTimeout
+		}, serveFetchOverDuplex(async (request) => await handler(request), { requestIdleMs }));
+		const onClose = (event) => {
+			if (event.data?.type === LINK_CLOSE) close();
+		};
+		const close = async () => {
+			port.removeEventListener("message", onClose);
+			await teardown();
+		};
+		port.addEventListener("message", onClose);
+		return close;
+	}
+	/**
+	* Wraps a `send` so the link knows its requests in flight (for draining and
+	* load-based routing) and can fail them all at once when it is closed.
+	*/
+	function trackedLink(send, release) {
+		let inflight = 0;
+		let closed = false;
+		let lostReason;
+		const failers = /* @__PURE__ */ new Set();
+		const idleWaiters = [];
+		const done = () => {
+			inflight--;
+			if (inflight === 0) for (const resolve of idleWaiters.splice(0)) resolve();
+		};
+		const link = {
+			get inflight() {
+				return inflight;
+			},
+			get closed() {
+				return closed;
+			},
+			whenIdle() {
+				return inflight === 0 ? Promise.resolve() : new Promise((r) => idleWaiters.push(r));
+			},
+			async send(request) {
+				if (closed) throw lostReason ?? new LinkLostError("The link is closed");
+				inflight++;
+				let finished = false;
+				const finish = () => {
+					if (finished) return;
+					finished = true;
+					failers.delete(fail);
+					done();
+				};
+				let fail = () => {};
+				const lost = new Promise((_, reject) => {
+					fail = reject;
+				});
+				failers.add(fail);
+				lost.catch(() => {});
+				let response;
+				try {
+					response = await Promise.race([send(request), lost]);
+				} catch (error) {
+					finish();
+					throw lostReason ?? error;
+				}
+				if (!response.body) {
+					finish();
+					return response;
+				}
+				return new Response(guardBody(response.body, lost, () => lostReason, finish), {
+					status: response.status,
+					statusText: response.statusText,
+					headers: response.headers
+				});
+			},
+			async close(reason) {
+				if (closed) return;
+				closed = true;
+				lostReason = reason ?? new LinkLostError("The link was closed");
+				for (const fail of [...failers]) fail(lostReason);
+				try {
+					await release();
+				} catch {}
+			}
+		};
+		return asyncDisposable(link, () => link.close());
+	}
+	/**
+	* A response body that reports its end (done, cancelled or failed) and fails
+	* with the link's reason when the link is lost mid-stream.
+	*/
+	function guardBody(body, lost, reason, finish) {
+		const reader = body.getReader();
+		return new ReadableStream({
+			async pull(controller) {
+				try {
+					const { done, value } = await Promise.race([reader.read(), lost]);
+					if (done) {
+						finish();
+						controller.close();
+						return;
+					}
+					controller.enqueue(value);
+				} catch (error) {
+					finish();
+					reader.cancel().catch(() => {});
+					controller.error(reason() ?? error);
+				}
+			},
+			async cancel(why) {
+				finish();
+				await reader.cancel(why).catch(() => {});
+			}
+		});
+	}
+	//#endregion
+	//#region src/link/locks.ts
+	function lockManager() {
+		return globalThis.navigator?.locks;
+	}
+	function locksAvailable() {
+		return lockManager() !== void 0;
+	}
+	/** A fresh lock name: `<prefix>:<uuid>`. */
+	function newLockName(prefix) {
+		return `${prefix}:${crypto.randomUUID()}`;
+	}
+	/**
+	* Takes the lock `name` and holds it until the returned release is called or
+	* this context dies. Resolves once the lock is held; with no Web Locks,
+	* resolves at once.
+	*/
+	async function holdLock(name) {
+		const locks = lockManager();
+		if (!locks) return () => {};
+		let release = () => {};
+		const released = new Promise((resolve) => {
+			release = resolve;
+		});
+		await new Promise((held) => {
+			locks.request(name, {}, () => {
+				held();
+				return released;
+			}).catch(() => held());
+		});
+		return release;
+	}
+	/**
+	* Calls `onLost` once the lock `name` is granted to this context — that is,
+	* once whoever holds it is gone — and releases it at once. Returns a function
+	* that stops watching. With no Web Locks, never calls `onLost`.
+	*/
+	function watchLock(name, onLost) {
+		const locks = lockManager();
+		if (!locks) return () => {};
+		const controller = new AbortController();
+		locks.request(name, { signal: controller.signal }, () => {
+			if (!controller.signal.aborted) onLost();
+		}).catch(() => {});
+		return () => controller.abort();
+	}
+	/**
+	* The names of the locks held right now in this origin, or `undefined` where
+	* that cannot be asked. A backup for `watchLock`: a grant can be late, a query
+	* cannot.
+	*/
+	async function heldLockNames() {
+		const locks = lockManager();
+		if (!locks?.query) return void 0;
+		try {
+			const { held = [] } = await locks.query();
+			return new Set(held.map((lock) => lock.name ?? ""));
+		} catch {
+			return;
+		}
+	}
+	//#endregion
+	//#region src/link/rendezvous.ts
+	/**
+	* Matches replies to requests by id, for the control messages that hand
+	* WebSocket ports across: each waiting request has a deadline, and all of a
+	* peer's waiting requests can be failed at once when the peer is lost.
+	*/
+	var PortRendezvous = class {
+		_prefix;
+		_waiting = /* @__PURE__ */ new Map();
+		_counter = 0;
+		constructor(_prefix = "r") {
+			this._prefix = _prefix;
+		}
+		/** A fresh id for a request. */
+		newId() {
+			return `${this._prefix}:${++this._counter}`;
+		}
+		get size() {
+			return this._waiting.size;
+		}
+		/** Waits for the reply to `id`, failing after `timeoutMs`. */
+		wait(id, timeoutMs, describe = "the reply") {
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					this._waiting.delete(id);
+					reject(/* @__PURE__ */ new Error(`No answer to ${describe} within ${timeoutMs} ms`));
+				}, timeoutMs);
+				this._waiting.set(id, {
+					resolve,
+					reject,
+					timer
+				});
+			});
+		}
+		/** Delivers the reply to `id`. `false` when nobody waits for it (it timed out). */
+		settle(id, value) {
+			const waiting = this._waiting.get(id);
+			if (!waiting) return false;
+			this._waiting.delete(id);
+			clearTimeout(waiting.timer);
+			waiting.resolve(value);
+			return true;
+		}
+		fail(id, error) {
+			const waiting = this._waiting.get(id);
+			if (!waiting) return;
+			this._waiting.delete(id);
+			clearTimeout(waiting.timer);
+			waiting.reject(error);
+		}
+		failAll(error) {
+			for (const id of [...this._waiting.keys()]) this.fail(id, error);
+		}
+	};
+	//#endregion
+	//#region src/ws/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;
+	}
+	function randomKey() {
+		const bytes = /* @__PURE__ */ new Uint8Array(16);
+		crypto.getRandomValues(bytes);
+		return btoa(String.fromCharCode(...bytes));
+	}
+	//#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 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";
+	//#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 stopClaims = handleClaimRequests(this.self);
-			const stopPortUpdates = handleChannelCalls(this.self, "UPDATE_COMMUNICATION_PORT", async (event, channelInfo, port) => {
-				const clientId = event.source?.id;
-				this.log("[UPDATE_COMMUNICATION_PORT]", clientId, channelInfo);
-				await this._updateChannelInfo({
-					...channelInfo,
-					port,
-					clientId
-				});
-				return { ...channelInfo };
-			});
-			this._cleanup = () => {
-				stopClaims();
-				stopPortUpdates();
+			const self = this.self;
+			if (this.routerLock) this._routerHeld = holdLock(this.routerLock).then(() => {});
+			this._restored = this._restoreClaimedKeys();
+			const latch = () => {
+				this._restoreSettled = true;
 			};
-			this.self.addEventListener("install", (event) => {
-				this.log("Skip waiting on install.", event);
-				this.self.skipWaiting();
-			});
-			this.self.addEventListener("activate", (event) => {
-				this.log("Claim control over all clients.", event);
-				event.waitUntil((async () => {
-					await this.self.clients.claim();
-					await this._checkActivation();
-				})());
+			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() {
-			if (this._cleanup) {
-				this._cleanup();
-				this._cleanup = void 0;
-			}
-		}
-		_checkActivation() {
-			if (!this._activationPromise) this._activationPromise = this._activate();
-			return this._activationPromise;
-		}
-		async _activate() {
-			this.log("[checkActivation]");
-			const clientsIndex = await this._loadClientIds();
-			for (const [clientId, client] of clientsIndex.entries()) {
-				const messageChannel = new MessageChannel();
-				const port = messageChannel.port1;
-				const channelInfo = await callChannel(client, "UPDATE_COMMUNICATION_PORT", {}, messageChannel.port2);
-				await this._updateChannelInfo({
-					...channelInfo,
-					port,
-					clientId
+			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)"
 				});
 			}
-		}
-		async _updateChannelInfo(channelInfo) {
-			this.log("[updateClientInfo]", channelInfo);
-			if (!channelInfo.clientId) return;
-			this.handlersIndex.set(channelInfo.clientId, channelInfo);
-			if (channelInfo.key && !this.claimedKeys.has(channelInfo.key)) {
-				this.claimedKeys.add(channelInfo.key);
-				await set("claimedKeys", [...this.claimedKeys].sort());
+			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" }
+				});
 			}
-			await this._updateClientIds([]);
 		}
-		async _loadClientIds() {
-			const storedKeys = await get("claimedKeys") ?? [];
-			for (const key of storedKeys) this.claimedKeys.add(key);
-			const stored = await get("clientIds") ?? [];
-			return await this._updateClientIds(new Set(stored));
+		/**
+		* 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;
 		}
-		async _updateClientIds(clientIds) {
-			const ids = new Set(clientIds);
-			for (const clientId of this.handlersIndex.keys()) ids.add(clientId);
-			const index = /* @__PURE__ */ new Map();
-			for (const clientId of ids) {
-				const client = await this.self.clients.get(clientId);
-				if (client) index.set(clientId, client);
-				else this.handlersIndex.delete(clientId);
+		_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;
 			}
-			await set("clientIds", [...index.keys()].sort());
-			return index;
+			event.respondWith((async () => {
+				await this._restored.catch(() => {});
+				if (!this.serves(key)) return await fetch(request);
+				return await this.dispatch(request);
+			})());
 		}
-	};
-	//#endregion
-	//#region src/sw/http-sw-dispatcher.ts
-	var SwHttpDispatcher = class extends SwPortDispatcher {
-		start() {
-			super.start();
-			this.self.addEventListener("fetch", this._handleFetchEvent.bind(this));
+		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
+			};
 		}
-		_handleFetchEvent(event) {
-			event.respondWith((async () => {
-				const request = event.request;
-				try {
-					const requestUrl = request.url;
-					const rootUrl = this.scope;
-					if (requestUrl.indexOf(rootUrl) === 0) {
-						const key = requestUrl.substring(rootUrl.length).replace(/^\/?([^/]+).*$/, "$1");
-						const channelInfo = await this.loadChannelInfo(key);
-						if (channelInfo?.port) return await sendHttpRequest(channelInfo.port, request);
-						if (this.isClaimedKey(key)) return new Response(null, {
-							status: 404,
-							statusText: "Not Found (no active handler)"
-						});
-					}
-					return await fetch(request);
-				} catch (error) {
-					console.error(error);
-					return new Response(null, {
-						status: 500,
-						statusText: "Error 500: Internal error"
-					});
+		_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();
@@ -1611,8 +3748,9 @@
 	//#endregion
 	//#region src/sw-worker.ts
 	startHttpDispatcher({
-		self,
-		log: console.log
+		log: console.log,
+		...self.HTTP_DISPATCHER_OPTIONS,
+		self
 	});
 	//#endregion
 })();