@statewalker/webrun-http-browser 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/webrun-http-browser",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "private": false,
   "type": "module",
   "description": "ServiceWorker-based HTTP and WebSocket server for browsers: handlers in pages and Dedicated Workers, same-origin and relay modes, streams with backpressure",
@@ -58,9 +58,9 @@
   ],
   "dependencies": {
     "idb-keyval": "^6.3.0",
-    "@statewalker/webrun-http-streams": "^0.3.0",
-    "@statewalker/webrun-rpc": "^0.5.0",
-    "@statewalker/webrun-streams": "^0.2.2"
+    "@statewalker/webrun-http-streams": "^0.3.2",
+    "@statewalker/webrun-streams": "^0.2.3",
+    "@statewalker/webrun-rpc": "^0.7.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.15",

package/src/link/async-dispose.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+export function asyncDisposable<T extends object>(target: T, dispose: () => Promise<unknown>): T {
+  // Read here, not at module level: a top-level read is code a bundler keeps.
+  const asyncDispose = (Symbol as { asyncDispose?: symbol }).asyncDispose;
+  if (asyncDispose && !(asyncDispose in target)) {
+    Object.defineProperty(target, asyncDispose, {
+      value: async () => {
+        await dispose();
+      },
+      configurable: true,
+      writable: true,
+    });
+  }
+  return target;
+}

package/src/link/http-link.ts

@@ -1,5 +1,6 @@
 import { fetchOverDuplex, serveFetchOverDuplex } from "@statewalker/webrun-http-streams";
 import { connect, overPipe, serve, structuredCodec } from "@statewalker/webrun-rpc";
+import { asyncDisposable } from "./async-dispose.js";
 
 /**
  * The version of the HTTP-over-`MessagePort` protocol this package speaks,
@@ -19,6 +20,20 @@ export interface HttpLinkOptions {
    * none: a slow consumer is throttled, never failed.
    */
   streamTimeout?: number;
+  /**
+   * Ceiling on the requests in flight on the link at once: webrun-rpc's
+   * `maxPorts`, one multiplexed port per request (default 1024). A request
+   * past it fails on the calling end; one the answering end has no room for is
+   * refused. Every exchange gives its port back when it ends, however it ends.
+   */
+  maxPorts?: number;
+  /**
+   * The answering end only: once a response is out, how long the request body
+   * may go unread before it is abandoned and the exchange ends (default 30 s;
+   * webrun-http-streams' `requestIdleMs`). A handler that answers first and
+   * reads the upload afterwards keeps it as long as it keeps reading.
+   */
+  requestIdleMs?: number;
 }
 
 /** The calling end of a link: sends requests, gets responses. */
@@ -62,10 +77,10 @@ const LINK_CLOSE = "webrun-http:link-close";
 /** Opens the calling end of a link on `port` (one port per link). */
 export async function connectHttpLink(
   port: MessagePort,
-  { streamTimeout }: HttpLinkOptions = {},
+  { streamTimeout, maxPorts }: HttpLinkOptions = {},
 ): Promise<HttpLink> {
   const { call, close } = await connect({
-    mux: overPipe(port, { codec: structuredCodec, side: "initiator" }),
+    mux: overPipe(port, { codec: structuredCodec, side: "initiator", maxPorts }),
     timeout: streamTimeout,
   });
   return trackedLink(
@@ -87,14 +102,14 @@ export async function connectHttpLink(
 export async function serveHttpLink(
   port: MessagePort,
   handler: (request: Request) => Response | Promise<Response>,
-  { streamTimeout }: HttpLinkOptions = {},
+  { streamTimeout, maxPorts, requestIdleMs }: HttpLinkOptions = {},
 ): Promise<() => Promise<void>> {
   const teardown = await serve(
     {
-      mux: overPipe(port, { codec: structuredCodec, side: "responder" }),
+      mux: overPipe(port, { codec: structuredCodec, side: "responder", maxPorts }),
       timeout: streamTimeout,
     },
-    serveFetchOverDuplex(async (request) => await handler(request)),
+    serveFetchOverDuplex(async (request) => await handler(request), { requestIdleMs }),
   );
   const onClose = (event: MessageEvent) => {
     if ((event.data as { type?: unknown } | null)?.type === LINK_CLOSE) void close();
@@ -166,7 +181,7 @@ export function trackedLink(
         return response;
       }
       return new Response(
-        guardBody(response.body, lost, () => lostReason, finish),
+        guardBody(response.body, lost, () => lostReason, finish, request.signal),
         {
           status: response.status,
           statusText: response.statusText,
@@ -184,39 +199,76 @@ export function trackedLink(
       } catch {}
     },
   };
-  return link;
+  // `await using link = await connectHttpLink(port)` closes it at the end of the block.
+  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.
+ * 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.
  */
 function guardBody(
   body: ReadableStream<Uint8Array>,
   lost: Promise<never>,
   reason: () => Error | undefined,
   finish: () => void,
+  signal: AbortSignal | undefined,
 ): ReadableStream<Uint8Array> {
   const reader = body.getReader();
+  let controller!: ReadableStreamDefaultController<Uint8Array>;
+  let ended = false;
+  const end = () => {
+    ended = true;
+    signal?.removeEventListener("abort", onAbort);
+    finish();
+  };
+  const onAbort = () => {
+    if (ended) return;
+    end();
+    void reader.cancel().catch(() => {});
+    try {
+      controller.error(abortError(signal as AbortSignal));
+    } catch {
+      /* already closed or errored */
+    }
+  };
   return new ReadableStream<Uint8Array>({
+    start(c) {
+      controller = c;
+      if (signal?.aborted) onAbort();
+      else signal?.addEventListener("abort", onAbort, { once: true });
+    },
     async pull(controller) {
       try {
         const { done, value } = await Promise.race([reader.read(), lost]);
+        if (ended) return;
         if (done) {
-          finish();
+          end();
           controller.close();
           return;
         }
         controller.enqueue(value);
       } catch (error) {
-        finish();
+        if (ended) return;
+        end();
         void reader.cancel().catch(() => {});
         controller.error(reason() ?? error);
       }
     },
     async cancel(why) {
-      finish();
+      end();
       await reader.cancel(why).catch(() => {});
     },
   });
 }
+
+/** The signal's reason as an `Error` (`AbortError` when it gave none). */
+function abortError(signal: AbortSignal): Error {
+  const why = (signal as unknown as { reason?: unknown }).reason;
+  if (why instanceof Error) return why;
+  const err = new Error(why === undefined ? "Aborted" : String(why));
+  err.name = "AbortError";
+  return err;
+}

package/src/sw/protocol.ts

@@ -93,11 +93,12 @@ export const WORKER_HELLO = "webrun-http:worker-hello";
 export type WorkerControlMessage =
   // worker → page, once: the worker serves, and holds this owner lock.
   | { type: "ready"; ownerLock?: string }
-  // page → worker: a fresh link (ports: down, ctl, up).
-  | { type: "link"; key: string; routerLock?: string }
+  // page → worker: a fresh link (ports: down, ctl, up), numbered per control port.
+  | { type: "link"; key: string; routerLock?: string; seq?: number }
   // page → worker: drop the links of this key.
   | { type: "unlink"; key: string }
   // worker → page: my links are dead and a call waits; attach me again.
-  | { type: "relink" }
+  // `seen`: the `seq` of the last link received on this port (0: none yet).
+  | { type: "relink"; seen?: number }
   // worker → page: a call is in flight; keep the ServiceWorker awake.
   | { type: "keepalive" };

package/src/sw/sw-http-adapter.ts

@@ -480,6 +480,8 @@ class WorkerLinkImpl implements WorkerLink {
   private readonly _ownerLock?: string;
   private _attaching?: Promise<void>;
   private _detached = false;
+  /** The `seq` of the last link sent to the worker. */
+  private _sent = 0;
 
   constructor(
     private readonly _adapter: SwHttpAdapter,
@@ -494,6 +496,10 @@ class WorkerLinkImpl implements WorkerLink {
     _control.onmessage = (event) => {
       const message = event.data as WorkerControlMessage;
       if (message?.type === "relink") {
+        // The worker has not received the latest link yet: it is on its way
+        // (a call made before it arrived asks too). Attaching again would
+        // replace the link a call is about to run on.
+        if (message.seen !== undefined && message.seen < this._sent) return;
         // Starts the ServiceWorker if it was stopped; the attach follows.
         this._adapter._poke(WAKE_MESSAGE);
         void this.attach().catch(() => {});
@@ -555,6 +561,7 @@ class WorkerLinkImpl implements WorkerLink {
             type: "link",
             key: this.key,
             routerLock: reply.routerLock,
+            seq: ++this._sent,
           } satisfies WorkerControlMessage,
           [down.port2, ctl.port2, up.port2],
         );

package/src/sw/worker-service.ts

@@ -64,12 +64,23 @@ export function serveHttpInWorker(
   const ownerLock = newLockName("webrun-http-owner");
   const held = holdLock(ownerLock);
   const controls = new Set<MessagePort>();
+  // Per control port, the `seq` of the last link received on it. A relink
+  // request carries it: the page attaches again only if this worker has its
+  // latest link, not while that link is still on its way.
+  const seen = new Map<MessagePort, number>();
   const tellPages = (message: WorkerControlMessage) => {
     for (const control of controls) control.postMessage(message);
   };
   const endpoint = new HandlerEndpoint(handler, {
     ...options,
-    requestRelink: () => tellPages({ type: "relink" }),
+    requestRelink: () => {
+      for (const control of controls) {
+        control.postMessage({
+          type: "relink",
+          seen: seen.get(control) ?? 0,
+        } satisfies WorkerControlMessage);
+      }
+    },
     keepAlive: () => tellPages({ type: "keepalive" }),
   });
 
@@ -82,6 +93,7 @@ export function serveHttpInWorker(
     control.onmessage = (message) => {
       const msg = message.data as WorkerControlMessage;
       if (msg?.type === "link") {
+        if (msg.seq !== undefined) seen.set(control, msg.seq);
         const [down, ctl, up] = message.ports;
         if (down) void endpoint.link(msg.key, { down, ctl, up }, msg.routerLock);
       } else if (msg?.type === "unlink") {
@@ -127,6 +139,7 @@ export function serveHttpInWorker(
       await endpoint.close();
       for (const control of controls) control.close();
       controls.clear();
+      seen.clear();
       (await held)();
     },
   };