@statewalker/webrun-http-browser 0.7.0 → 0.7.1

package/dist/relay-sw.js

@@ -23,8 +23,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 +175,6 @@
 			drainQueue();
 		}
 	}
-	new TextEncoder();
 	/**
 	* The iterator ↔ `ReadableStream` boundary.
 	*
@@ -447,8 +444,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:
 	*
@@ -702,15 +699,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
@@ -1015,7 +1012,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
@@ -1065,7 +1062,7 @@
 	* 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]
 	});
@@ -1119,41 +1116,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 {}
+	}
 	/**
 	* 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
@@ -1345,14 +1406,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);
@@ -1367,13 +1432,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;
-	}
 	var HttpError = class HttpError extends Error {
 		status;
 		statusText;
@@ -1748,6 +1806,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
@@ -1784,7 +1905,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 {
@@ -1798,7 +1919,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
@@ -2194,9 +2317,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() {
@@ -2242,6 +2378,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,
@@ -2271,11 +2428,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
 		});
@@ -2300,7 +2458,7 @@
 			inflight--;
 			if (inflight === 0) for (const resolve of idleWaiters.splice(0)) resolve();
 		};
-		return {
+		const link = {
 			get inflight() {
 				return inflight;
 			},
@@ -2353,6 +2511,7 @@
 				} catch {}
 			}
 		};
+		return asyncDisposable(link, () => link.close());
 	}
 	/**
 	* A response body that reports its end (done, cancelled or failed) and fails