@statewalker/webrun-http-browser 0.3.4 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/webrun-http-browser",
-  "version": "0.3.4",
+  "version": "0.4.2",
   "private": false,
   "type": "module",
   "description": "ServiceWorker-based HTTP server for browsers, with relay and same-origin dispatch modes",
@@ -42,8 +42,9 @@
   ],
   "dependencies": {
     "idb-keyval": "^6.3.0",
-    "@statewalker/webrun-streams": "0.1.1",
-    "@statewalker/webrun-http-streams": "0.2.1"
+    "@statewalker/webrun-http-streams": "0.2.2",
+    "@statewalker/webrun-rpc": "0.4.0",
+    "@statewalker/webrun-streams": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",

package/src/core/data-channels.ts

@@ -125,11 +125,18 @@ export async function* sendStream<T>(
   communicationPort.postMessage({ type: "START_CALL", params }, [messageChannel.port2]);
 
   const channel = newStreamChannel<T>(messageChannel.port1);
+  let drained = false;
   try {
     await channel.start();
     void channel.sendAll(input);
     yield* channel.recieveAll();
+    drained = true;
   } finally {
+    // A caller that stops early — an aborted `fetch`, a cancelled response
+    // body, a `break` — has to TELL the peer. Closing a `MessagePort` does not
+    // notify the other end, so without this the handler on the far side keeps
+    // producing into a port nobody reads, for the life of the page.
+    if (!drained) channel.cancel();
     await channel.close();
   }
 }
@@ -168,26 +175,57 @@ export function handleStreams<T>(
 interface StreamChannel<T> {
   start(): Promise<void>;
   close(): Promise<void>;
+  /** Tell the peer we have stopped reading, so it can release its producer. */
+  cancel(): void;
   recieveAll(): AsyncGenerator<T, void, unknown>;
   sendAll(it: AsyncIterable<T>): Promise<void>;
 }
 
+/** A data chunk, or — with `cancel` — the peer saying it has stopped reading. */
+type StreamMessage<T> = { done?: boolean; value?: T; error?: unknown; cancel?: boolean };
+
 function newStreamChannel<T>(port: MessageTarget): StreamChannel<T> {
-  type DataListener = (msg: { done?: boolean; value?: T; error?: unknown }) => Promise<boolean>;
+  type DataListener = (msg: StreamMessage<T>) => Promise<boolean>;
   let listeners: DataListener[] = [];
   let iterators: AsyncIterable<T>[] = [];
 
-  const notifyAll = async (data: { done?: boolean; value?: T; error?: unknown }) => {
+  const notifyAll = async (data: StreamMessage<T>) => {
     for (const listener of listeners) await listener(data);
   };
 
+  /**
+   * Release whatever we are sending. NOT awaited: `.return()` on an async
+   * generator parked awaiting its own source is queued behind that pending
+   * `next()`, so awaiting it here would block the message handler — and the
+   * chunk that would unblock it can only arrive through that same handler.
+   */
+  const cancelOutgoing = (): void => {
+    for (const it of [...iterators]) {
+      const iterable = it as AsyncIterable<T> & { return?: () => unknown };
+      void Promise.resolve(iterable.return?.()).catch(() => {});
+    }
+  };
+
   const channel = newInvokationChannel({
     port,
-    handler: (data: unknown) => notifyAll(data as { done?: boolean; value?: T; error?: unknown }),
+    handler: (data: unknown) => {
+      const message = data as StreamMessage<T>;
+      if (message?.cancel) {
+        cancelOutgoing();
+        return;
+      }
+      return notifyAll(message);
+    },
   });
 
   const start = () => channel.start();
 
+  const cancel = (): void => {
+    // Best effort by design: the port may already be gone, and a peer that
+    // never hears this is no worse off than before the message existed.
+    void channel.invoke({ cancel: true }).catch(() => {});
+  };
+
   const close = async () => {
     await notifyAll({ done: true });
     for (const it of [...iterators]) {
@@ -220,5 +258,5 @@ function newStreamChannel<T>(port: MessageTarget): StreamChannel<T> {
     );
   }
 
-  return { start, close, recieveAll, sendAll };
+  return { start, close, cancel, recieveAll, sendAll };
 }

package/src/core/message-target.ts

@@ -1,18 +1,8 @@
-export type MessageListener = (event: MessageEvent) => void | Promise<void>;
-
-/** An object we can listen for `"message"` events on. */
-export interface MessageSource {
-  addEventListener(type: "message", listener: MessageListener): void;
-  removeEventListener(type: "message", listener: MessageListener): void;
-  start?(): void | Promise<void>;
-}
-
-/** An object we can post messages to (with optional transferable list). */
-export interface MessageSink {
-  postMessage(message: unknown, transfer?: Transferable[]): void;
-}
-
-/** Full-duplex message target: both sends and receives. */
-export interface MessageTarget extends MessageSource, MessageSink {
-  close?(): void | Promise<void>;
-}
+// Re-exported from @statewalker/webrun-rpc, which owns the port layer, so this
+// package's five internal importers and its public API are unchanged.
+export type {
+  MessageListener,
+  MessageSink,
+  MessageSource,
+  MessageTarget,
+} from "@statewalker/webrun-rpc";

package/src/http/http-send-recieve.ts

@@ -39,13 +39,21 @@ async function httpFromIterator<Options>(
 }
 
 /**
- * @deprecated For new code, prefer the `MessagePort`-based stack from
- * `@statewalker/webrun-http-port`. Once a `MessagePort` is established between
- * page and worker, `httpServe(port, handler)` provides equivalent semantics
- * with `callBidi` multiplexing, full-duplex streaming, and `AbortSignal`.
- * This helper remains for existing ServiceWorker setups that still consume the
- * `MessageTarget` surface; it will be reimplemented on top of
- * `webrun-http-port` in a follow-up release.
+ * Serve an `HttpHandler` over a `MessageTarget`, using this package's own
+ * `handleStreams` transport.
+ *
+ * @deprecated Prefer the port stack in `@statewalker/webrun-rpc`: open a port
+ * (`multiplexPort` over one pipe, or `transferPortMux` where the platform can
+ * transfer a real `MessagePort`), turn it into a `Duplex` with
+ * `serveDuplexOverPort`, and serve HTTP on that with
+ * `httpServe(handler, options)` from `@statewalker/webrun-http-streams`.
+ *
+ * That path has backpressure; **this one does not.** `sendStream`'s chunk
+ * sender discards the promise it is given, so a fast producer over a slow
+ * consumer accumulates without bound. It also has no per-stream timeout and no
+ * chunking to a transport's message ceiling.
+ *
+ * Kept for existing ServiceWorker setups built on the `MessageTarget` surface.
  */
 export function handleHttpRequests(
   communicationPort: MessageTarget,
@@ -60,13 +68,18 @@ export function handleHttpRequests(
 }
 
 /**
- * @deprecated For new code, prefer the `MessagePort`-based stack from
- * `@statewalker/webrun-http-port/fetch`. Once the page and SW share a
- * `MessagePort`, `fetchOverPort(port, request)` provides the same
- * `Request → Response` semantics with multiplexing via `callBidi`, JSONL
- * envelope framing, and native `AbortSignal` support. This helper remains for
- * existing ServiceWorker setups; it will be reimplemented on top of
- * `webrun-http-port` in a follow-up release.
+ * Ship a `Request` over a `MessageTarget` and await the `Response`, using this
+ * package's own `sendStream` transport.
+ *
+ * @deprecated Prefer the port stack in `@statewalker/webrun-rpc`: open a port
+ * (`multiplexPort` over one pipe, or `transferPortMux` where the platform can
+ * transfer a real `MessagePort`), turn it into a `Duplex` with
+ * `duplexOverPort`, and drive HTTP over it with `httpFetch` from
+ * `@statewalker/webrun-http-streams`.
+ *
+ * Same caveat as {@link handleHttpRequests}: the transport underneath this
+ * helper has no backpressure, no per-stream timeout, and no chunking to a
+ * transport's message ceiling. Kept for existing ServiceWorker setups.
  */
 export async function sendHttpRequest(
   communicationPort: MessageTarget,

package/src/sw/sw-dispatcher.ts

@@ -47,7 +47,12 @@ export class SwPortHandler {
   get serviceWorkerUrl(): string {
     if (!this._serviceWorkerUrl) {
       const url = this.options.serviceWorkerUrl
-        ? new URL(this.options.serviceWorkerUrl)
+        ? // A worker url is relative to the document that registers it, so it
+          // is resolved against `location.href` like any other url a page
+          // writes. Without the base, the root-relative form callers actually
+          // use — `"/sw-worker.js"` — threw a bare `Invalid URL` naming
+          // neither the option nor the value.
+          resolveWorkerUrl(this.options.serviceWorkerUrl)
         : new URL("./index-sw.js", this.rootUrl);
       this._serviceWorkerUrl = `${url}`;
     }
@@ -305,3 +310,23 @@ export class SwPortDispatcher {
     return index;
   }
 }
+
+/**
+ * Resolve a `serviceWorkerUrl` option the way a page would: relative to the
+ * current document. Absolute urls pass through untouched. A url that cannot
+ * be resolved is reported with the option name and the offending value,
+ * because the raw `TypeError: Failed to construct 'URL': Invalid URL` says
+ * neither.
+ */
+function resolveWorkerUrl(serviceWorkerUrl: string): URL {
+  const base = globalThis.location?.href;
+  try {
+    return new URL(serviceWorkerUrl, base);
+  } catch (error) {
+    throw new Error(
+      `Invalid serviceWorkerUrl: ${JSON.stringify(serviceWorkerUrl)}` +
+        (base ? ` (relative to ${base})` : " (no document to resolve it against)"),
+      { cause: error },
+    );
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2026 statewalker
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.