@statewalker/webrun-http-browser 0.7.1 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/webrun-http-browser",
-  "version": "0.7.1",
+  "version": "0.10.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-rpc": "^0.8.0",
     "@statewalker/webrun-streams": "^0.2.3",
-    "@statewalker/webrun-rpc": "^0.5.1",
-    "@statewalker/webrun-http-streams": "^0.3.1"
+    "@statewalker/webrun-http-streams": "^0.4.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.15",

package/src/link/http-link.ts

@@ -181,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,
@@ -204,35 +204,71 @@ export function trackedLink(
 }
 
 /**
- * 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)();
     },
   };