@volter/tabnode 0.5.12 → 0.5.14

package/dist/index.d.ts

@@ -33,7 +33,7 @@ export { PackageManager, install } from './npm';
 export { ServerBridge, getServerBridge, resetServerBridge } from './server-bridge';
 export type { InitServiceWorkerOptions } from './server-bridge';
 /** What a page's request is answered with, the shape the bridge answers. */
-export type { ResponseData } from './node-lib/http-bridge';
+export type { ResponseData, LoopbackStreamFlow } from './node-lib/http-bridge';
 export * as esbuild from './shims/esbuild';
 export * as rollup from './shims/rollup';
 export * as module from './shims/module';

package/dist/index.mjs

@@ -37278,13 +37278,14 @@ function __requestOverLoopback(port, method, url2, headers, body) {
     if (body && body.length > 0) socket.write(body);
   });
 }
-function __streamOverLoopback(port, method, url2, headers, body, onStart, onChunk, onEnd) {
+function __streamOverLoopback(port, method, url2, headers, body, onStart, onChunk, onEnd, flow) {
   if (!__listening(port)) {
     onStart(503, "Service Unavailable", { "Content-Type": "text/plain" });
     onEnd();
     return Promise.resolve();
   }
   return new Promise((resolve2) => {
+    var _a2;
     const collected = emptyCollected();
     let started2 = false;
     let ended = false;
@@ -37304,6 +37305,18 @@ function __streamOverLoopback(port, method, url2, headers, body, onStart, onChun
       (chunk) => onChunk(chunk)
     );
     const socket = netModule.connect({ port, host: "127.0.0.1" });
+    (_a2 = flow == null ? void 0 : flow.control) == null ? void 0 : _a2.call(flow, () => socket.pause(), () => socket.resume());
+    if (flow == null ? void 0 : flow.signal) {
+      if (flow.signal.aborted) {
+        socket.destroy();
+        finish();
+        return;
+      }
+      flow.signal.addEventListener("abort", () => {
+        socket.destroy();
+        finish();
+      }, { once: true });
+    }
     socket.on("data", (chunk) => {
       if (ended) return;
       const read = parser.execute(chunk);
@@ -37380,6 +37393,9 @@ function __upgradeOverLoopback(port, method, url2, headers) {
   });
 }
 const _encoder = new TextEncoder();
+const FLOW_MAX_REQUEST_BYTES = 64 * 1024 * 1024;
+const FLOW_MAX_CHUNK_BYTES = 65536;
+const FLOW_QUEUED_CHUNKS = 4;
 function ownedBytes(view) {
   const copy2 = new Uint8Array(view.byteLength);
   copy2.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
@@ -37649,6 +37665,8 @@ const _ServerBridge = class _ServerBridge extends EventEmitter {
     /** The server the service worker answers at the origin's root, the preview's; null for none. */
     __publicField(this, "primaryPort", null);
     __publicField(this, "ownDocuments");
+    /** Flow-controlled requests in flight: a pull is one chunk's credit, a cancel ends the upstream. */
+    __publicField(this, "controlledStreams", /* @__PURE__ */ new Map());
     this.options = options;
     if (typeof location !== "undefined") {
       this.baseUrl = options.baseUrl || `${location.protocol}//${location.host}`;
@@ -37819,6 +37837,7 @@ const _ServerBridge = class _ServerBridge extends EventEmitter {
     await controllerReady;
     const reinit = () => {
       if (navigator.serviceWorker.controller) {
+        for (const stream of [...this.controlledStreams.values()]) stream.cancel();
         this.messageChannel = new MessageChannel();
         this.messageChannel.port1.onmessage = this.handleServiceWorkerMessage.bind(this);
         navigator.serviceWorker.controller.postMessage(
@@ -37850,6 +37869,17 @@ const _ServerBridge = class _ServerBridge extends EventEmitter {
     var _a2, _b2, _c2;
     const { type: type2, id, data: data2 } = event.data;
     _ServerBridge.DEBUG && console.log("[ServerBridge] SW message:", type2, id, data2 == null ? void 0 : data2.url);
+    if (type2 === "stream-pull" || type2 === "stream-cancel") {
+      const stream = this.controlledStreams.get(id);
+      if (type2 === "stream-pull") stream == null ? void 0 : stream.pull();
+      else stream == null ? void 0 : stream.cancel();
+      return;
+    }
+    if (type2 === "request" && (data2 == null ? void 0 : data2.flowControl) === 1) {
+      const { port, method, url: url2, headers, body } = data2;
+      await this.controlledStream(id, port, method, url2, headers, body);
+      return;
+    }
     if (type2 === "request") {
       const { port, method, url: url2, headers, body, streaming } = data2;
       _ServerBridge.DEBUG && console.log("[ServerBridge] Handling request:", port, method, url2, "streaming:", streaming);
@@ -37898,7 +37928,7 @@ const _ServerBridge = class _ServerBridge extends EventEmitter {
    * it; a server the host registered answers through its own streaming
    * method where it has one, else its buffered answer is delivered whole.
    */
-  async handleStreamingRequest(port, method, url2, headers, body, callbacks) {
+  async handleStreamingRequest(port, method, url2, headers, body, callbacks, flow) {
     const virtualServer = this.servers.get(port);
     if (!virtualServer) return false;
     const bodyBuffer = body ? Buffer$9.from(new Uint8Array(body)) : void 0;
@@ -37913,7 +37943,8 @@ const _ServerBridge = class _ServerBridge extends EventEmitter {
         bodyBuffer,
         (statusCode, statusMessage, respHeaders) => callbacks.start(statusCode, statusMessage, respHeaders),
         (chunk) => callbacks.chunk(ownedBytes(chunk)),
-        () => callbacks.end()
+        () => callbacks.end(),
+        flow
       );
       return true;
     }
@@ -37926,7 +37957,8 @@ const _ServerBridge = class _ServerBridge extends EventEmitter {
         bodyBuffer,
         (statusCode, statusMessage, respHeaders) => callbacks.start(statusCode, statusMessage, respHeaders),
         (chunk) => callbacks.chunk(typeof chunk === "string" ? _encoder.encode(chunk) : ownedBytes(chunk)),
-        () => callbacks.end()
+        () => callbacks.end(),
+        flow
       );
       return true;
     }
@@ -38043,7 +38075,91 @@ const _ServerBridge = class _ServerBridge extends EventEmitter {
    */
   notifyServiceWorker(type2, data2) {
     if (this.serviceWorkerReady && this.messageChannel) {
-      this.messageChannel.port1.postMessage({ type: type2, data: data2 });
+      const flow = type2 === "server-registered" ? { flowControl: 1, maxRequestBytes: FLOW_MAX_REQUEST_BYTES, maxChunkBytes: FLOW_MAX_CHUNK_BYTES } : {};
+      this.messageChannel.port1.postMessage({ type: type2, data: { ...data2, ...flow } });
+    }
+  }
+  /**
+   * A request the worker sent under flow control: the response starts with
+   * its head, then goes one chunk (at most FLOW_MAX_CHUNK_BYTES) for each
+   * `stream-pull`, and ends with `stream-end` once the server finished and
+   * every chunk went out. The upstream connection is paused while chunks wait
+   * for credit, so a slow reader holds the server back; `stream-cancel` ends it.
+   */
+  async controlledStream(id, port, method, url2, headers, body) {
+    const channel = this.messageChannel;
+    const post = (type2, data2) => {
+      channel == null ? void 0 : channel.port1.postMessage({ type: type2, id, ...data2 === void 0 ? {} : { data: data2 } });
+    };
+    const queue = [];
+    const abort = new AbortController();
+    let credits = 0;
+    let upstreamEnded = false;
+    let finished = false;
+    let paused = false;
+    let pause = () => void 0;
+    let resume = () => void 0;
+    const finish = () => {
+      finished = true;
+      this.controlledStreams.delete(id);
+    };
+    const flush = () => {
+      if (finished) return;
+      while (credits > 0 && queue.length > 0) {
+        credits -= 1;
+        post("stream-chunk", { chunkBase64: uint8ToBase64(queue.shift()) });
+      }
+      if (upstreamEnded && queue.length === 0) {
+        post("stream-end");
+        finish();
+        return;
+      }
+      if (queue.length >= FLOW_QUEUED_CHUNKS && !paused) {
+        paused = true;
+        pause();
+      } else if (queue.length < FLOW_QUEUED_CHUNKS && paused) {
+        paused = false;
+        resume();
+      }
+    };
+    this.controlledStreams.set(id, {
+      pull: () => {
+        credits += 1;
+        flush();
+      },
+      cancel: () => {
+        if (finished) return;
+        finish();
+        queue.length = 0;
+        abort.abort();
+      }
+    });
+    try {
+      const answered = await this.handleStreamingRequest(port, method, url2, headers, body, {
+        start: (statusCode, statusMessage, respHeaders) => post("stream-start", { statusCode, statusMessage, headers: respHeaders }),
+        chunk: (chunk) => {
+          if (finished) return;
+          for (let at2 = 0; at2 < chunk.byteLength; at2 += FLOW_MAX_CHUNK_BYTES) queue.push(chunk.slice(at2, at2 + FLOW_MAX_CHUNK_BYTES));
+          flush();
+        },
+        end: () => {
+          upstreamEnded = true;
+          flush();
+        }
+      }, { signal: abort.signal, control: (p, r) => {
+        pause = p;
+        resume = r;
+      } });
+      if (!answered) {
+        post("stream-start", { statusCode: 503, statusMessage: "Service Unavailable", headers: {} });
+        post("stream-end");
+        finish();
+      }
+    } catch (error) {
+      if (!finished) {
+        post("stream-error", { message: error instanceof Error ? error.message : String(error) });
+        finish();
+      }
     }
   }
   /**

package/dist/node-lib/http-bridge.d.ts

@@ -22,7 +22,17 @@ export declare function __requestOverLoopback(port: number, method: string, url:
  * the server writes, then the end. This is what the service worker streams
  * to the page.
  */
-export declare function __streamOverLoopback(port: number, method: string, url: string, headers: Record<string, string>, body: Buffer | undefined, onStart: (statusCode: number, statusMessage: string, headers: Record<string, string>) => void, onChunk: (chunk: Uint8Array) => void, onEnd: () => void): Promise<void>;
+/**
+ * How a caller paces a streamed answer: `signal` ends the connection (the
+ * reader went away), and `control` is handed the connection's pause and
+ * resume, so a reader that holds no credit holds the server back instead of
+ * a queue growing without bound.
+ */
+export interface LoopbackStreamFlow {
+    signal?: AbortSignal;
+    control?(pause: () => void, resume: () => void): void;
+}
+export declare function __streamOverLoopback(port: number, method: string, url: string, headers: Record<string, string>, body: Buffer | undefined, onStart: (statusCode: number, statusMessage: string, headers: Record<string, string>) => void, onChunk: (chunk: Uint8Array) => void, onEnd: () => void, flow?: LoopbackStreamFlow): Promise<void>;
 /** What an upgrade answered with: the 101 and the socket the page now owns. */
 export interface UpgradeResult {
     statusCode: number;

package/dist/server-bridge.d.ts

@@ -2,7 +2,7 @@
  * Server Bridge
  * Connects Service Worker requests to virtual HTTP servers
  */
-import { type ResponseData } from './node-lib/http-bridge';
+import { type ResponseData, type LoopbackStreamFlow } from './node-lib/http-bridge';
 import { EventEmitter } from './node-lib/events-module';
 /**
  * Interface for virtual servers that can be registered with the bridge
@@ -125,12 +125,22 @@ export declare class ServerBridge extends EventEmitter {
         start(statusCode: number, statusMessage: string, headers: Record<string, string>): void;
         chunk(chunk: Uint8Array): void;
         end(): void;
-    }): Promise<boolean>;
+    }, flow?: LoopbackStreamFlow): Promise<boolean>;
     private streamToServiceWorker;
     /**
      * Send message to Service Worker
      */
     private notifyServiceWorker;
+    /** Flow-controlled requests in flight: a pull is one chunk's credit, a cancel ends the upstream. */
+    private readonly controlledStreams;
+    /**
+     * A request the worker sent under flow control: the response starts with
+     * its head, then goes one chunk (at most FLOW_MAX_CHUNK_BYTES) for each
+     * `stream-pull`, and ends with `stream-end` once the server finished and
+     * every chunk went out. The upstream connection is paused while chunks wait
+     * for credit, so a slow reader holds the server back; `stream-cancel` ends it.
+     */
+    private controlledStream;
     /**
      * Create a mock request handler for testing without Service Worker
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.12",
+  "version": "0.5.14",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -38,7 +38,7 @@ export { PackageManager, install } from './npm';
 export { ServerBridge, getServerBridge, resetServerBridge } from './server-bridge';
 export type { InitServiceWorkerOptions } from './server-bridge';
 /** What a page's request is answered with, the shape the bridge answers. */
-export type { ResponseData } from './node-lib/http-bridge';
+export type { ResponseData, LoopbackStreamFlow } from './node-lib/http-bridge';
 // The bundlers' own wasm builds, as doors: a host that builds outside a run
 // (the substrate's rolldown pass) reaches them here rather than through a
 // guest's `require`.

package/src/node-lib/http-bridge.ts

@@ -195,11 +195,23 @@ export function __requestOverLoopback(
  * the server writes, then the end. This is what the service worker streams
  * to the page.
  */
+/**
+ * How a caller paces a streamed answer: `signal` ends the connection (the
+ * reader went away), and `control` is handed the connection's pause and
+ * resume, so a reader that holds no credit holds the server back instead of
+ * a queue growing without bound.
+ */
+export interface LoopbackStreamFlow {
+  signal?: AbortSignal;
+  control?(pause: () => void, resume: () => void): void;
+}
+
 export function __streamOverLoopback(
   port: number, method: string, url: string, headers: Record<string, string>, body: Buffer | undefined,
   onStart: (statusCode: number, statusMessage: string, headers: Record<string, string>) => void,
   onChunk: (chunk: Uint8Array) => void,
   onEnd: () => void,
+  flow?: LoopbackStreamFlow,
 ): Promise<void> {
   if (!__listening(port)) {
     onStart(503, 'Service Unavailable', { 'Content-Type': 'text/plain' });
@@ -217,6 +229,11 @@ export function __streamOverLoopback(
       (chunk) => onChunk(chunk),
     );
     const socket = netModule.connect({ port, host: '127.0.0.1' }) as unknown as Socket;
+    flow?.control?.(() => socket.pause(), () => socket.resume());
+    if (flow?.signal) {
+      if (flow.signal.aborted) { socket.destroy(); finish(); return; }
+      flow.signal.addEventListener('abort', () => { socket.destroy(); finish(); }, { once: true });
+    }
     socket.on('data', (chunk: Uint8Array) => {
       if (ended) return;
       const read = parser.execute(chunk);

package/src/server-bridge.ts

@@ -5,7 +5,7 @@
 
 import {
   __requestOverLoopback, __streamOverLoopback, __upgradeOverLoopback, __listening,
-  type ResponseData,
+  type ResponseData, type LoopbackStreamFlow,
 } from './node-lib/http-bridge';
 import { setPortWatchers } from './node-lib/net-module';
 import { EventEmitter } from './node-lib/events-module';
@@ -15,6 +15,12 @@ import { Buffer } from './node-lib/buffer-module';
 import { uint8ToBase64 } from './utils/binary-encoding';
 
 const _encoder = new TextEncoder();
+// The worker's flow-controlled stream: a request body up to this size, and a
+// response in chunks of exactly the worker's own maximum, one per pull.
+const FLOW_MAX_REQUEST_BYTES = 64 * 1024 * 1024;
+const FLOW_MAX_CHUNK_BYTES = 65536;
+// Chunks that may wait for the reader's credit before the server is paused.
+const FLOW_QUEUED_CHUNKS = 4;
 
 /** The bytes this view names, in a buffer of their own. A pooled Buffer is a window on 8 KB. */
 function ownedBytes(view: Uint8Array): Uint8Array {
@@ -649,6 +655,7 @@ export class ServerBridge extends EventEmitter {
     // to all clients when a request arrives but mainPort is null.
     const reinit = () => {
       if (navigator.serviceWorker.controller) {
+        for (const stream of [...this.controlledStreams.values()]) stream.cancel();
         this.messageChannel = new MessageChannel();
         this.messageChannel.port1.onmessage = this.handleServiceWorkerMessage.bind(this);
         navigator.serviceWorker.controller.postMessage(
@@ -684,6 +691,16 @@ export class ServerBridge extends EventEmitter {
 
     ServerBridge.DEBUG && console.log('[ServerBridge] SW message:', type, id, data?.url);
 
+    if (type === 'stream-pull' || type === 'stream-cancel') {
+      const stream = this.controlledStreams.get(id);
+      if (type === 'stream-pull') stream?.pull(); else stream?.cancel();
+      return;
+    }
+    if (type === 'request' && data?.flowControl === 1) {
+      const { port, method, url, headers, body } = data;
+      await this.controlledStream(id, port, method, url, headers, body);
+      return;
+    }
     if (type === 'request') {
       const { port, method, url, headers, body, streaming } = data;
 
@@ -752,6 +769,7 @@ export class ServerBridge extends EventEmitter {
       chunk(chunk: Uint8Array): void;
       end(): void;
     },
+    flow?: LoopbackStreamFlow,
   ): Promise<boolean> {
     const virtualServer = this.servers.get(port);
     if (!virtualServer) return false;
@@ -764,6 +782,7 @@ export class ServerBridge extends EventEmitter {
         (statusCode, statusMessage, respHeaders) => callbacks.start(statusCode, statusMessage, respHeaders),
         (chunk) => callbacks.chunk(ownedBytes(chunk)),
         () => callbacks.end(),
+        flow,
       );
       return true;
     }
@@ -773,14 +792,18 @@ export class ServerBridge extends EventEmitter {
         onStart: (statusCode: number, statusMessage: string, headers: Record<string, string>) => void,
         onChunk: (chunk: string | Uint8Array) => void,
         onEnd: () => void,
+        flow?: LoopbackStreamFlow,
       ) => Promise<void>;
     };
     if (typeof server.handleStreamingRequest === 'function') {
+      // a registered server that streams is paced the same way: it is handed
+      // the reader's going away and the pause and resume of its own producer
       await server.handleStreamingRequest(
         method, url, headers, bodyBuffer,
         (statusCode, statusMessage, respHeaders) => callbacks.start(statusCode, statusMessage, respHeaders),
         (chunk) => callbacks.chunk(typeof chunk === 'string' ? _encoder.encode(chunk) : ownedBytes(chunk)),
         () => callbacks.end(),
+        flow,
       );
       return true;
     }
@@ -909,7 +932,71 @@ export class ServerBridge extends EventEmitter {
    */
   private notifyServiceWorker(type: string, data: unknown): void {
     if (this.serviceWorkerReady && this.messageChannel) {
-      this.messageChannel.port1.postMessage({ type, data });
+      // Every port this bridge answers speaks the worker's flow-controlled
+      // stream: a response is paced by the reader's pulls, one chunk a pull,
+      // and a reader that goes away ends the request (virtual HTTP flow
+      // control, the worker's side of which is in public/__sw__.js).
+      const flow = type === 'server-registered'
+        ? { flowControl: 1, maxRequestBytes: FLOW_MAX_REQUEST_BYTES, maxChunkBytes: FLOW_MAX_CHUNK_BYTES } : {};
+      this.messageChannel.port1.postMessage({ type, data: { ...(data as object), ...flow } });
+    }
+  }
+
+  /** Flow-controlled requests in flight: a pull is one chunk's credit, a cancel ends the upstream. */
+  private readonly controlledStreams = new Map<number, { pull(): void; cancel(): void }>();
+
+  /**
+   * A request the worker sent under flow control: the response starts with
+   * its head, then goes one chunk (at most FLOW_MAX_CHUNK_BYTES) for each
+   * `stream-pull`, and ends with `stream-end` once the server finished and
+   * every chunk went out. The upstream connection is paused while chunks wait
+   * for credit, so a slow reader holds the server back; `stream-cancel` ends it.
+   */
+  private async controlledStream(id: number, port: number, method: string, url: string, headers: Record<string, string>, body?: ArrayBuffer): Promise<void> {
+    // the stream belongs to the channel it arrived on; a new channel's worker failed it already
+    const channel = this.messageChannel;
+    const post = (type: string, data?: unknown): void => { channel?.port1.postMessage({ type, id, ...(data === undefined ? {} : { data }) }); };
+    const queue: Uint8Array[] = [];
+    const abort = new AbortController();
+    let credits = 0;
+    let upstreamEnded = false;
+    let finished = false;
+    let paused = false;
+    let pause = (): void => undefined;
+    let resume = (): void => undefined;
+    const finish = (): void => { finished = true; this.controlledStreams.delete(id); };
+    const flush = (): void => {
+      if (finished) return;
+      while (credits > 0 && queue.length > 0) {
+        credits -= 1;
+        post('stream-chunk', { chunkBase64: uint8ToBase64(queue.shift()!) });
+      }
+      if (upstreamEnded && queue.length === 0) { post('stream-end'); finish(); return; }
+      // a few chunks may wait for credit; more than that, and the server waits
+      if (queue.length >= FLOW_QUEUED_CHUNKS && !paused) { paused = true; pause(); }
+      else if (queue.length < FLOW_QUEUED_CHUNKS && paused) { paused = false; resume(); }
+    };
+    this.controlledStreams.set(id, {
+      pull: () => { credits += 1; flush(); },
+      cancel: () => { if (finished) return; finish(); queue.length = 0; abort.abort(); },
+    });
+    try {
+      const answered = await this.handleStreamingRequest(port, method, url, headers, body, {
+        start: (statusCode, statusMessage, respHeaders) => post('stream-start', { statusCode, statusMessage, headers: respHeaders }),
+        chunk: (chunk) => {
+          if (finished) return;
+          for (let at = 0; at < chunk.byteLength; at += FLOW_MAX_CHUNK_BYTES) queue.push(chunk.slice(at, at + FLOW_MAX_CHUNK_BYTES));
+          flush();
+        },
+        end: () => { upstreamEnded = true; flush(); },
+      }, { signal: abort.signal, control: (p, r) => { pause = p; resume = r; } });
+      if (!answered) {
+        post('stream-start', { statusCode: 503, statusMessage: 'Service Unavailable', headers: {} });
+        post('stream-end');
+        finish();
+      }
+    } catch (error) {
+      if (!finished) { post('stream-error', { message: error instanceof Error ? error.message : String(error) }); finish(); }
     }
   }