@statewalker/webrun-http-browser 0.7.0 → 0.7.1

package/dist/sw-worker.js

@@ -74,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
@@ -228,7 +226,6 @@
 			drainQueue();
 		}
 	}
-	new TextEncoder();
 	/**
 	* The iterator ↔ `ReadableStream` boundary.
 	*
@@ -574,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:
 	*
@@ -829,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
@@ -1142,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
@@ -1192,10 +1189,29 @@
 	* Writes HTTP/1.1; accepts HTTP/1.1 or the legacy JSON envelope. Used whenever
 	* no `codec` option is supplied.
 	*/
-	const defaultCodec = newSniffingCodec({
+	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`. */
@@ -1273,41 +1289,105 @@
 	*/
 	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));
-		const decoded = await codec.decodeResponse(output, { method: env.method });
-		const release = async () => {
-			try {
-				await output.return?.(void 0);
-			} catch {}
+		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, release),
-			release
+			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`, but leaving it before its end releases the call.
+	* `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 `.return()` on it never reaches the call's `output` (see
-	* `throwIfPeerError` for why the codec must not do that itself). So a caller
-	* that stopped reading — an aborted `fetch`, a cancelled response stream —
-	* left the peer's producer parked forever, holding its handler open. Safe here
-	* for the same reason it is safe in `throwIfPeerError`: `output` is this
-	* call's own response-only generator, and the request was fully sent.
-	*/
-	async function* releasingOnExit(body, release) {
+	* 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) await release();
+			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`.
@@ -1335,6 +1415,7 @@
 			try {
 				yield* replyCodec.encodeResponse(result.envelope, result.body, { method: decoded.envelope.method });
 				completed = true;
+				await result.settled?.();
 			} finally {
 				if (!completed) try {
 					await result.release?.();
@@ -1558,14 +1639,18 @@
 			const buffered = new Uint8Array(await request.arrayBuffer());
 			if (buffered.byteLength > 0) body = [buffered];
 		}
-		const { envelope, body: respBody, release } = await httpFetch(call, env, body, options);
+		const { 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)) {
-			await release?.();
+			if (finish) finish();
+			else await release?.();
 			return new Response(null, responseInit);
 		}
 		return new Response(asyncIterableToReadable(withAbort(respBody, request.signal)), responseInit);
@@ -1580,13 +1665,21 @@
 				method: env.method,
 				headers: forwardableHeaders(env.headers)
 			};
+			let upload;
 			if (env.method !== "GET" && env.method !== "HEAD") {
 				if (supportsRequestStreams()) {
-					reqInit.body = asyncIterableToReadable(body);
+					upload = trackingEnd(body);
+					reqInit.body = asyncIterableToReadable(upload.source);
 					reqInit.duplex = "half";
 				} else reqInit.body = await collectBytes(body);
 			}
-			const response = await handler(new Request(env.url, reqInit));
+			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,
@@ -1596,16 +1689,101 @@
 				await response.body?.cancel();
 				return {
 					envelope: respEnv,
-					body: void 0
+					body: void 0,
+					settled
 				};
 			}
 			return {
 				envelope: respEnv,
 				body: response.body ? readableToAsyncIterable(response.body) : void 0,
-				release: () => response.body?.cancel()
+				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;
@@ -1616,13 +1794,6 @@
 			yield chunk;
 		}
 	}
-	function abortReason$1(signal) {
-		const reason = signal.reason;
-		if (reason instanceof Error) return reason;
-		const err = new Error(reason === void 0 ? "Aborted" : String(reason));
-		err.name = "AbortError";
-		return err;
-	}
 	//#endregion
 	//#region src/core/data-channels.ts
 	const MESSAGE_TYPE_REQUEST = "REQUEST";
@@ -1980,6 +2151,69 @@
 		}
 	}
 	/**
+	* 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.
+	*
+	* 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 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));
+	}
+	/**
 	* The `type` of the out-of-band notice a side posts when it abandons a stream.
 	*
 	* Layer 1's `close` is not observable to layer 2 — a closed virtual port drops
@@ -2075,7 +2309,7 @@
 		const inbound = receiveChunks(port, CHANNEL_OUT, controller, clock.touch);
 		const pump = sendChunks(port, CHANNEL_IN, input, options, controller.signal, clock.touch);
 		pump.catch(() => {});
-		return (async function* () {
+		return returningAtOnce((async function* () {
 			try {
 				yield* inbound.stream;
 			} finally {
@@ -2089,7 +2323,9 @@
 					await port.close?.();
 				} catch {}
 			}
-		})();
+		})(), () => {
+			if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: the caller abandoned the stream"));
+		});
 	}
 	/**
 	* Listens for the peer's abort notice, and can post our own. The notice is a
@@ -2485,9 +2721,22 @@
 			maxMessageSize: mux.maxMessageSize,
 			timeout
 		};
-		const call = (input) => (async function* () {
-			yield* duplexOverPort(await mux.openPort(STREAM_META), streamOptions)(input);
-		})();
+		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() {
@@ -2578,6 +2827,27 @@
 		}
 	};
 	//#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,
@@ -2607,11 +2877,12 @@
 	*/
 	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 } = {}) {
+	async function connectHttpLink(port, { streamTimeout, maxPorts } = {}) {
 		const { call, close } = await connect({
 			mux: overPipe(port, {
 				codec: structuredCodec,
-				side: "initiator"
+				side: "initiator",
+				maxPorts
 			}),
 			timeout: streamTimeout
 		});
@@ -2627,14 +2898,15 @@
 	* that abandons the requests still running (their handlers see the
 	* cancellation) and releases the port.
 	*/
-	async function serveHttpLink(port, handler, { streamTimeout } = {}) {
+	async function serveHttpLink(port, handler, { streamTimeout, maxPorts, requestIdleMs } = {}) {
 		const teardown = await serve({
 			mux: overPipe(port, {
 				codec: structuredCodec,
-				side: "responder"
+				side: "responder",
+				maxPorts
 			}),
 			timeout: streamTimeout
-		}, serveFetchOverDuplex(async (request) => await handler(request)));
+		}, serveFetchOverDuplex(async (request) => await handler(request), { requestIdleMs }));
 		const onClose = (event) => {
 			if (event.data?.type === LINK_CLOSE) close();
 		};
@@ -2659,7 +2931,7 @@
 			inflight--;
 			if (inflight === 0) for (const resolve of idleWaiters.splice(0)) resolve();
 		};
-		return {
+		const link = {
 			get inflight() {
 				return inflight;
 			},
@@ -2712,6 +2984,7 @@
 				} catch {}
 			}
 		};
+		return asyncDisposable(link, () => link.close());
 	}
 	/**
 	* A response body that reports its end (done, cancelled or failed) and fails