@statewalker/webrun-http-browser 0.12.1 → 0.12.3

package/src/link/http-link.ts

@@ -196,14 +196,18 @@ export function trackedLink(
         finish();
         return response;
       }
-      return new Response(
-        guardBody(response.body, lost, () => lostReason, finish, request.signal),
-        {
-          status: response.status,
-          statusText: response.statusText,
-          headers: response.headers,
-        },
-      );
+      // From here the body fails with the link's reason when the link closes:
+      // `fail` becomes the body's, and `finish` removes whichever is current.
+      failers.delete(fail);
+      const body = guardBody(response.body, finish, request);
+      fail = body.fail;
+      if (closed) fail(lostReason as Error);
+      else if (!finished) failers.add(fail);
+      return new Response(body.stream, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
     },
     async close(reason) {
       if (closed) return;
@@ -220,37 +224,43 @@ export function trackedLink(
 }
 
 /**
- * A response body that reports its end (done, cancelled, failed or aborted) and
- * fails with the link's reason when the link is lost mid-stream. An abort of the
- * request's signal ends it at once, read or not: the exchange is over (the layer
- * below has given its port back), so the request leaves `inflight` then.
+ * A response body that reports its end (done, cancelled, failed or aborted).
+ * `fail(error)` ends it with `error` at once — the link calls it when it is lost
+ * mid-stream. An abort of the request's signal does the same with the signal's
+ * reason, read or not: the exchange is over (the layer below has given its port
+ * back), so the request leaves `inflight` then. A read waits on the reader
+ * alone, so nothing outlives the chunk it brings.
  */
 function guardBody(
   body: ReadableStream<Uint8Array>,
-  lost: Promise<never>,
-  reason: () => Error | undefined,
   finish: () => void,
-  signal: AbortSignal | undefined,
-): ReadableStream<Uint8Array> {
+  request: Request,
+): { stream: ReadableStream<Uint8Array>; fail: (error: Error) => void } {
+  // Held until the body ends: the Request's signal follows the caller's signal only while the
+  // Request lives (Node's undici holds the Request's controller through a WeakRef), and a caller may keep only the Response.
+  const keep: { request?: Request } = { request };
+  const signal: AbortSignal | undefined = request.signal ?? undefined;
   const reader = body.getReader();
   let controller!: ReadableStreamDefaultController<Uint8Array>;
   let ended = false;
   const end = () => {
     ended = true;
     signal?.removeEventListener("abort", onAbort);
+    keep.request = undefined;
     finish();
   };
-  const onAbort = () => {
+  const fail = (error: Error) => {
     if (ended) return;
     end();
     void reader.cancel().catch(() => {});
     try {
-      controller.error(abortError(signal as AbortSignal));
+      controller.error(error);
     } catch {
       /* already closed or errored */
     }
   };
-  return new ReadableStream<Uint8Array>({
+  const onAbort = () => fail(abortError(signal as AbortSignal));
+  const stream = new ReadableStream<Uint8Array>({
     start(c) {
       controller = c;
       if (signal?.aborted) onAbort();
@@ -258,7 +268,7 @@ function guardBody(
     },
     async pull(controller) {
       try {
-        const { done, value } = await Promise.race([reader.read(), lost]);
+        const { done, value } = await reader.read();
         if (ended) return;
         if (done) {
           end();
@@ -267,17 +277,22 @@ function guardBody(
         }
         controller.enqueue(value);
       } catch (error) {
-        if (ended) return;
-        end();
-        void reader.cancel().catch(() => {});
-        controller.error(reason() ?? error);
+        fail(error as Error);
       }
     },
-    async cancel(why) {
+    cancel(why) {
       end();
-      await reader.cancel(why).catch(() => {});
+      // The body is cancelled a macrotask later, not at once. Between two of its pulls it has
+      // no read in flight (the stream holds the next `pull` until the last one settles, for a
+      // few microtasks), and a cancel landing there abandons the call even with its end on the
+      // way. A macrotask later it has either closed (its end came: the call is finished, and
+      // an upload the handler reads after answering goes on) or started its next read, which
+      // then decides as `fetchOverDuplex`'s body does. How many microtasks the gap lasts
+      // differs between engines (Node 22 and 24 do). `cancel()` does not wait for it.
+      setTimeout(() => void reader.cancel(why).catch(() => {}), 0);
     },
   });
+  return { stream, fail };
 }
 
 /** The signal's reason as an `Error` (`AbortError` when it gave none). */

package/src/sw/worker-service.ts

@@ -127,10 +127,21 @@ export function serveHttpInWorker(
 
   return {
     fetch(input, init) {
+      // A Request built from another follows its signal only as long as the other lives (in Node,
+      // undici links them weakly): pass the signal on directly, so a caller who keeps neither
+      // can still abort.
       const request =
         input instanceof Request && init === undefined
           ? input
-          : new Request(input instanceof Request ? input : new URL(`${input}`, baseUrl()), init);
+          : new Request(input instanceof Request ? input : new URL(`${input}`, baseUrl()), {
+              ...init,
+              signal:
+                init && "signal" in init
+                  ? init.signal
+                  : input instanceof Request
+                    ? input.signal
+                    : undefined,
+            });
       return endpoint.fetch(request);
     },
     connectWebSocket,

package/src/ws/frames.ts

@@ -100,20 +100,26 @@ export function messageSize(data: string | ArrayBuffer): number {
   return typeof data === "string" ? utf8Length(data) : data.byteLength;
 }
 
-/** The UTF-8 length of `text`, without encoding it. */
+const encoder = new TextEncoder();
+/** Characters encoded per `encodeInto` call: at most 3 bytes each, so the scratch stays at 96 KiB. */
+const CHUNK = 32_768;
+const scratch = new Uint8Array(CHUNK * 3);
+
+/**
+ * The UTF-8 length of `text`, as `TextEncoder` would encode it (a lone surrogate counts as the 3
+ * bytes of U+FFFD). Every message is measured on both ends (`bufferedAmount` and the byte acks), so
+ * this runs natively: `encodeInto` a reused buffer, a chunk at a time, never splitting a surrogate
+ * pair across two chunks. A loop over the characters in JavaScript took about 30 times as long.
+ */
 export function utf8Length(text: string): number {
   let length = 0;
-  for (let i = 0; i < text.length; i++) {
-    const code = text.charCodeAt(i);
-    if (code < 0x80) length += 1;
-    else if (code < 0x800) length += 2;
-    else if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {
-      const next = text.charCodeAt(i + 1);
-      if (next >= 0xdc00 && next <= 0xdfff) {
-        length += 4;
-        i++;
-      } else length += 3;
-    } else length += 3;
+  for (let start = 0; start < text.length; ) {
+    let end = Math.min(start + CHUNK, text.length);
+    // A high surrogate ending the chunk goes with its low surrogate into the next one.
+    const last = text.charCodeAt(end - 1);
+    if (end < text.length && last >= 0xd800 && last <= 0xdbff) end--;
+    length += encoder.encodeInto(text.slice(start, end), scratch).written;
+    start = end;
   }
   return length;
 }