@statewalker/webrun-http-streams 0.2.5 → 0.3.0

package/dist/fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../src/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAAE,KAAK,eAAe,EAAwB,MAAM,gBAAgB,CAAC;AAsF5E;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,QAAQ,CAAC,CA0EnB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAChD,OAAO,GAAE,eAAoB,GAC5B,MAAM,CAiDR"}
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../src/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAAE,KAAK,eAAe,EAAwB,MAAM,gBAAgB,CAAC;AAsF5E;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,QAAQ,CAAC,CAiDnB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAChD,OAAO,GAAE,eAAoB,GAC5B,MAAM,CAqDR"}

package/dist/http-data.d.ts

@@ -9,10 +9,25 @@ export type HttpDataOptions = {
 export interface HttpFetchResult {
     envelope: ResponseEnvelope;
     body: AsyncIterable<Uint8Array>;
+    /**
+     * Abandons the call: the peer's producer is released (its `finally` runs).
+     * Leaving `body` early — `break`, `.return()`, a cancelled stream — does
+     * the same; this is for a caller that never starts reading it, such as a
+     * bodyless response. Optional, so that results built elsewhere (mocks,
+     * custom transports) still type-check; `httpFetch` always sets it.
+     */
+    release?(): Promise<void>;
 }
 export interface HttpDataHandlerResult {
     envelope: ResponseEnvelope;
     body?: ByteSource;
+    /**
+     * Called when the caller abandons the response before its end. A body the
+     * codec never started pulling cannot be released through the iterator
+     * protocol (`.return()` on a generator in suspended start does nothing), so
+     * a producer that holds resources says here how to let them go.
+     */
+    release?: () => unknown;
 }
 /**
  * Low-level HTTP-over-Duplex handler. Takes the request envelope plus body

package/dist/http-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-data.d.ts","sourceRoot":"","sources":["../src/http-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAK1D,OAAO,KAAK,EACV,UAAU,EAEV,YAAY,EACZ,eAAe,EACf,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAEtB,gEAAgE;AAChE,eAAO,MAAM,iBAAiB,mBAAmB,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG;IAC5B,gFAAgF;IAChF,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAgGpC;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,IAAI,CAAC,EAAE,UAAU,EACjB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,eAAe,CAAC,CAM1B;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,GAAE,eAAoB,GAAG,MAAM,CAwCzF"}
+{"version":3,"file":"http-data.d.ts","sourceRoot":"","sources":["../src/http-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAK1D,OAAO,KAAK,EACV,UAAU,EAEV,YAAY,EACZ,eAAe,EACf,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAEtB,gEAAgE;AAChE,eAAO,MAAM,iBAAiB,mBAAmB,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG;IAC5B,gFAAgF;IAChF,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAChC;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAgGpC;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,IAAI,CAAC,EAAE,UAAU,EACjB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,eAAe,CAAC,CAkB1B;AA0BD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,GAAE,eAAoB,GAAG,MAAM,CAoDzF"}

package/dist/index.js

@@ -855,11 +855,41 @@ async function throwIfPeerError(result, output) {
 async function httpFetch(call, env, body, options = {}) {
 	const codec = options.codec ?? defaultCodec;
 	const output = call(codec.encodeRequest(env, body));
-	const result = await codec.decodeResponse(output, { method: env.method });
+	const decoded = await codec.decodeResponse(output, { method: env.method });
+	const release = async () => {
+		try {
+			await output.return?.(void 0);
+		} catch {}
+	};
+	const result = {
+		envelope: decoded.envelope,
+		body: releasingOnExit(decoded.body, release),
+		release
+	};
 	await throwIfPeerError(result, output);
 	return result;
 }
 /**
+* `body`, but leaving it before its end releases the call.
+*
+* The body the codec hands back is a generator of its own over a `ByteReader`,
+* and `.return()` on it never reaches the call's `output` (see
+* `throwIfPeerError` for why the codec must not do that itself). So a caller
+* that stopped reading — an aborted `fetch`, a cancelled response stream —
+* left the peer's producer parked forever, holding its handler open. Safe here
+* for the same reason it is safe in `throwIfPeerError`: `output` is this
+* call's own response-only generator, and the request was fully sent.
+*/
+async function* releasingOnExit(body, release) {
+	let completed = false;
+	try {
+		yield* body;
+		completed = true;
+	} finally {
+		if (!completed) await release();
+	}
+}
+/**
 * Wrap an HTTP handler as a `Duplex` so it can be registered with any
 * `webrun-streams-*` adapter's `serve`.
 */
@@ -882,7 +912,15 @@ function httpServe(handler, options = {}) {
 			yield* encodeErrorResponse(replyCodec, error, decoded.envelope.method);
 			return;
 		}
-		yield* replyCodec.encodeResponse(result.envelope, result.body, { method: decoded.envelope.method });
+		let completed = false;
+		try {
+			yield* replyCodec.encodeResponse(result.envelope, result.body, { method: decoded.envelope.method });
+			completed = true;
+		} finally {
+			if (!completed) try {
+				await result.release?.();
+			} catch {}
+		}
 	};
 }
 //#endregion
@@ -1140,14 +1178,14 @@ async function fetchOverDuplex(call, request, options = {}) {
 		const buffered = new Uint8Array(await request.arrayBuffer());
 		if (buffered.byteLength > 0) body = [buffered];
 	}
-	const { envelope, body: respBody } = await httpFetch(call, env, body, options);
+	const { envelope, body: respBody, release } = await httpFetch(call, env, body, options);
 	const responseInit = {
 		status: envelope.status,
 		statusText: envelope.statusText,
 		headers: forwardableHeaders(envelope.headers)
 	};
 	if (request.method === "HEAD" || request.method === "OPTIONS" || NULL_BODY_STATUSES.has(envelope.status)) {
-		await respBody.return?.();
+		await release?.();
 		return new Response(null, responseInit);
 	}
 	return new Response(asyncIterableToReadable(withAbort(respBody, request.signal)), responseInit);
@@ -1183,7 +1221,8 @@ function serveFetchOverDuplex(handler, options = {}) {
 		}
 		return {
 			envelope: respEnv,
-			body: response.body ? readableToAsyncIterable(response.body) : void 0
+			body: response.body ? readableToAsyncIterable(response.body) : void 0,
+			release: () => response.body?.cancel()
 		};
 	}, options);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/webrun-http-streams",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
   "description": "HTTP request/response over a webrun-streams Duplex, encoded as HTTP/1.1, plus transport-agnostic fetch stubs",

package/src/fetch.ts

@@ -126,46 +126,21 @@ export async function fetchOverDuplex(
     const buffered = new Uint8Array(await request.arrayBuffer());
     if (buffered.byteLength > 0) body = [buffered];
   }
-  const { envelope, body: respBody } = await httpFetch(call, env, body, options);
+  const { envelope, body: respBody, release } = await httpFetch(call, env, body, options);
   const responseInit: ResponseInit = {
     status: envelope.status,
     statusText: envelope.statusText,
     headers: forwardableHeaders(envelope.headers),
   };
   // `new Response(body, { status })` throws for the null-body-status set, and
-  // HEAD/OPTIONS carry no body either, so return a bodyless Response and try to
-  // let go of the body we were handed.
-  //
-  // KNOWN GAP — this `.return()` does not actually release the producer, and
-  // `discard` would not fix it either. Do not read it as a working drain.
-  //
-  // `respBody` is *not* the generator the codec pulled from. `decodeResponse`
-  // pulls from its `input` (the `output` generator returned by `call(...)`) to
-  // read the head, and hands back a freshly constructed one —
-  // `convertBodyErrors(readBody(...))` in `http1/decode.ts`. Nobody has pulled
-  // from that, so it is in suspended start and `.return()` on it is a no-op,
-  // exactly as in the two sites `http-stubs.ts` fixed. Measured: the producer's
-  // `finally` does not run for 204, 205, 304, HEAD+200 or OPTIONS+200.
-  //
-  // `discard` does not help because the release has to reach further down.
-  // `ByteReader` never propagates `.return()` to its own `#iter`, so only
-  // `await output.return()` frees the underlying call — and `fetchOverDuplex`
-  // has no handle on `output`, since `httpFetch` returns only `{envelope,
-  // body}`. Closing this needs `httpFetch` to expose the call for cancellation;
-  // that is a design change, not a patch here.
-  //
-  // Worth knowing which shapes leak a *populated* body rather than an empty
-  // one: `decodeResponse`'s own bodyless test covers status < 200, 204, 304 and
-  // HEAD, so for 205 and for OPTIONS the decoder frames a real body that is
-  // then abandoned. `http-data.ts` (see `throwIfPeerError`) spells out the cost
-  // on a mux transport — one stream-table slot per call, until `maxStreams`.
+  // HEAD/OPTIONS carry no body either, so return a bodyless Response and
+  // release the call: nobody will read the body, so leaving it cannot.
   if (
     request.method === "HEAD" ||
     request.method === "OPTIONS" ||
     NULL_BODY_STATUSES.has(envelope.status)
   ) {
-    const returnable = respBody as AsyncIterable<Uint8Array> & { return?: () => unknown };
-    await returnable.return?.();
+    await release?.();
     return new Response(null, responseInit);
   }
   return new Response(asyncIterableToReadable(withAbort(respBody, request.signal)), responseInit);
@@ -225,6 +200,10 @@ export function serveFetchOverDuplex(
     return {
       envelope: respEnv,
       body: response.body ? readableToAsyncIterable(response.body) : undefined,
+      // A body the codec never started reading has no reader to cancel
+      // through; cancel the stream itself. Once read, it is locked and this
+      // rejects, harmlessly: the reader's own cancellation has run.
+      release: () => response.body?.cancel(),
     };
   }, options);
 }

package/src/http-data.ts

@@ -22,11 +22,26 @@ export type HttpDataOptions = {
 export interface HttpFetchResult {
   envelope: ResponseEnvelope;
   body: AsyncIterable<Uint8Array>;
+  /**
+   * Abandons the call: the peer's producer is released (its `finally` runs).
+   * Leaving `body` early — `break`, `.return()`, a cancelled stream — does
+   * the same; this is for a caller that never starts reading it, such as a
+   * bodyless response. Optional, so that results built elsewhere (mocks,
+   * custom transports) still type-check; `httpFetch` always sets it.
+   */
+  release?(): Promise<void>;
 }
 
 export interface HttpDataHandlerResult {
   envelope: ResponseEnvelope;
   body?: ByteSource;
+  /**
+   * Called when the caller abandons the response before its end. A body the
+   * codec never started pulling cannot be released through the iterator
+   * protocol (`.return()` on a generator in suspended start does nothing), so
+   * a producer that holds resources says here how to let them go.
+   */
+  release?: () => unknown;
 }
 
 /**
@@ -152,11 +167,47 @@ export async function httpFetch(
 ): Promise<HttpFetchResult> {
   const codec = options.codec ?? defaultCodec;
   const output = call(codec.encodeRequest(env, body));
-  const result = await codec.decodeResponse(output, { method: env.method });
+  const decoded = await codec.decodeResponse(output, { method: env.method });
+  const release = async () => {
+    try {
+      await output.return?.(undefined);
+    } catch {
+      /* the call is being abandoned; nothing to report */
+    }
+  };
+  const result: HttpFetchResult = {
+    envelope: decoded.envelope,
+    body: releasingOnExit(decoded.body, release),
+    release,
+  };
   await throwIfPeerError(result, output);
   return result;
 }
 
+/**
+ * `body`, but leaving it before its end releases the call.
+ *
+ * The body the codec hands back is a generator of its own over a `ByteReader`,
+ * and `.return()` on it never reaches the call's `output` (see
+ * `throwIfPeerError` for why the codec must not do that itself). So a caller
+ * that stopped reading — an aborted `fetch`, a cancelled response stream —
+ * left the peer's producer parked forever, holding its handler open. Safe here
+ * for the same reason it is safe in `throwIfPeerError`: `output` is this
+ * call's own response-only generator, and the request was fully sent.
+ */
+async function* releasingOnExit(
+  body: AsyncIterable<Uint8Array>,
+  release: () => Promise<void>,
+): AsyncGenerator<Uint8Array> {
+  let completed = false;
+  try {
+    yield* body;
+    completed = true;
+  } finally {
+    if (!completed) await release();
+  }
+}
+
 /**
  * Wrap an HTTP handler as a `Duplex` so it can be registered with any
  * `webrun-streams-*` adapter's `serve`.
@@ -197,8 +248,20 @@ export function httpServe(handler: HttpDataHandler, options: HttpDataOptions = {
       yield* encodeErrorResponse(replyCodec, error, decoded.envelope.method);
       return;
     }
-    yield* replyCodec.encodeResponse(result.envelope, result.body, {
-      method: decoded.envelope.method,
-    });
+    let completed = false;
+    try {
+      yield* replyCodec.encodeResponse(result.envelope, result.body, {
+        method: decoded.envelope.method,
+      });
+      completed = true;
+    } finally {
+      if (!completed) {
+        try {
+          await result.release?.();
+        } catch {
+          /* already released through the body, or nothing to release */
+        }
+      }
+    }
   };
 }