@volter/tabnode 0.5.11 → 0.5.13

package/dist/assets/{runtime-worker-C5pP4aT7.js → runtime-worker-CQv8H3sj.js}

@@ -17621,17 +17621,10 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply;
-var hasRequiredFunctionApply;
-function requireFunctionApply() {
-  if (hasRequiredFunctionApply) return functionApply;
-  hasRequiredFunctionApply = 1;
-  functionApply = Function.prototype.apply;
-  return functionApply;
-}
+var functionApply = Function.prototype.apply;
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = requireFunctionApply();
+var $apply$1 = functionApply;
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -17751,7 +17744,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = requireFunctionApply();
+var $apply = functionApply;
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -18392,7 +18385,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = requireFunctionApply();
+  var $apply2 = functionApply;
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);

package/dist/index.d.ts

@@ -44,6 +44,7 @@ import { Runtime, RuntimeOptions } from './runtime';
 import { PackageManager } from './npm';
 import { ServerBridge } from './server-bridge';
 import { type Socket as NetSocket } from './node-lib/net-module';
+import { type NativeStreamHandleView } from './native-stream-owner';
 import { runPid, processByPid } from './process-tokens';
 export { runPid, processByPid };
 export { createProcessRegistryScope, installProcessRegistry, ownerProcessRegistryScope, ownerProcessTable } from './process-tokens';
@@ -52,7 +53,7 @@ export type { NodeProcessLaunch, NodeProcessHost } from './node-process-host';
 export type { ProcessIdentity, ProcessRegistry, ProcessRegistryScope, InitialProcessRegistration } from './process-registry';
 export { NativeStreamScope } from './native-stream-owner';
 export { installNativeStreamTransport, nativeStreamDescriptor } from './native-stream-binding';
-export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport } from './native-stream-owner';
+export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport, NativeStreamHandleView } from './native-stream-owner';
 export interface RunResult {
     stdout: string;
     stderr: string;
@@ -116,6 +117,8 @@ export declare function createContainer(options?: ContainerOptions): {
     processPorts: (token: string) => number[];
     /** The pid of the process listening on a port of this engine, where a guest process is: `/proc`'s socket owner. */
     portPid: (port: number) => number | undefined;
+    /** The stream handles the processes of other workers hold through this engine: `/proc/<pid>/fd`. */
+    streamHandles: () => NativeStreamHandleView[];
     /** Deliver a signal to the named run as another process's `kill(pid)` does; false when the run is gone. */
     signalProcess: (token: string, signal: string) => boolean;
     stopProcess: (token: string) => boolean;

package/dist/index.mjs

@@ -35728,7 +35728,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-C5pP4aT7.js",
+        "/assets/runtime-worker-CQv8H3sj.js",
         import.meta.url
       ),
       { type: "module" }
@@ -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;
     }
@@ -38043,7 +38074,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();
+      }
     }
   }
   /**
@@ -38098,6 +38213,7 @@ function resetServerBridge() {
   globalBridge = null;
 }
 const scopes = /* @__PURE__ */ new WeakMap();
+const liveScopes = /* @__PURE__ */ new Set();
 class NativeStreamScope {
   /**
    * `ownerPid` names the process whose worker this scope serves: a listener
@@ -38116,6 +38232,19 @@ class NativeStreamScope {
     this.ownerPid = ownerPid;
     if ([limits.maxHandles, limits.maxReadChunkBytes, limits.maxQueuedBytes, limits.maxQueuedHandles, limits.maxPendingWriteBytes].some((value) => !Number.isSafeInteger(value) || value < 1) || limits.maxReadChunkBytes > 2147483647 || limits.maxReadChunkBytes > limits.maxQueuedBytes || limits.maxReadChunkBytes > limits.maxPendingWriteBytes) throw new Error("Invalid native stream resource limits.");
     this.limits = Object.freeze({ ...limits });
+    liveScopes.add(this);
+  }
+  /** This scope's open handles, with the process it serves. */
+  handles() {
+    var _a2;
+    if (this.disposed) return [];
+    const pid = (_a2 = this.ownerPid) == null ? void 0 : _a2.call(this);
+    return [...this.entries.values()].map(({ handle, descriptor }) => ({
+      ...pid !== void 0 ? { pid } : {},
+      id: descriptor.id,
+      kind: descriptor.kind,
+      listening: !!handle.listening
+    }));
   }
   entry(id) {
     return this.disposed ? void 0 : this.entries.get(id);
@@ -38387,6 +38516,7 @@ class NativeStreamScope {
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    liveScopes.delete(this);
     const failures = [];
     for (const id of [...this.entries.keys()]) {
       try {
@@ -38402,6 +38532,9 @@ function nativeStreamOwnerPid(handle) {
   var _a2, _b2;
   return (_b2 = (_a2 = scopes.get(handle)) == null ? void 0 : _a2.ownerPid) == null ? void 0 : _b2.call(_a2);
 }
+function nativeStreamHandles() {
+  return [...liveScopes].flatMap((scope) => scope.handles());
+}
 let __nextRunName = 1;
 function createContainer(options) {
   const vfs2 = options && options.vfs || new VirtualFS();
@@ -38464,6 +38597,7 @@ function createContainer(options) {
       if (!listener) return void 0;
       return ((_a2 = runPid(ownerOf(listener))) == null ? void 0 : _a2.pid) ?? nativeStreamOwnerPid(listener);
     },
+    streamHandles: () => nativeStreamHandles(),
     /**
      * Deliver a signal to the named run as another process's `kill(pid)` does:
      * the guest's listeners for it run, else its default action ends the run.

package/dist/native-stream-owner.d.ts

@@ -88,6 +88,13 @@ export interface NativeStreamTransport {
     write(id: number, bytes: Uint8Array, handle?: number): Promise<number>;
     onEvent(listener: (event: NativeStreamEvent) => void): () => void;
 }
+/** One open stream handle, as a process's descriptor table shows it. */
+export interface NativeStreamHandleView {
+    pid?: number;
+    id: number;
+    kind: 'tcp' | 'pipe';
+    listening: boolean;
+}
 /**
  * One capability namespace per worker. Only the trusted host can inherit a
  * descriptor from another scope; wire operations can name this scope's IDs only.
@@ -108,6 +115,8 @@ export declare class NativeStreamScope {
      * it opens is that process's socket, as the container's /proc shows it.
      */
     constructor(limits: NativeStreamLimits, emit: (event: NativeStreamEvent) => void, ownerPid?: (() => number | undefined) | undefined);
+    /** This scope's open handles, with the process it serves. */
+    handles(): NativeStreamHandleView[];
     private entry;
     private publish;
     private claim;
@@ -126,3 +135,5 @@ export declare class NativeStreamScope {
 }
 /** The process a handle opened for another worker's process belongs to, where a scope holds it. */
 export declare function nativeStreamOwnerPid(handle: object): number | undefined;
+/** Every open native stream handle in this worker, by the process each scope serves. */
+export declare function nativeStreamHandles(): NativeStreamHandleView[];

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.11",
+  "version": "0.5.13",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -56,7 +56,7 @@ import { runCommand, registerRunStreams, releaseRunStreams, sendStdin } from './
 import { Server as NetServer, __releaseOwnedHandles, type Socket as NetSocket } from './node-lib/net-module';
 import { __adoptHandle, ownerOf, type OwnedHandle } from './node-lib/binding/handles';
 import { listenerOnPort } from './node-lib/binding/tcp_wrap';
-import { nativeStreamOwnerPid } from './native-stream-owner';
+import { nativeStreamHandles, nativeStreamOwnerPid, type NativeStreamHandleView } from './native-stream-owner';
 
 import { __currentProcessToken, __runFor, __signalOwnedProcess, __takeTermination, __stopOwnedProcess, runPid, processByPid } from './process-tokens';
 export { runPid, processByPid };
@@ -66,7 +66,7 @@ export type { NodeProcessLaunch, NodeProcessHost } from './node-process-host';
 export type { ProcessIdentity, ProcessRegistry, ProcessRegistryScope, InitialProcessRegistration } from './process-registry';
 export { NativeStreamScope } from './native-stream-owner';
 export { installNativeStreamTransport, nativeStreamDescriptor } from './native-stream-binding';
-export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport } from './native-stream-owner';
+export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport, NativeStreamHandleView } from './native-stream-owner';
 
 export interface RunResult {
   stdout: string;
@@ -129,6 +129,8 @@ export function createContainer(options?: ContainerOptions): {
   processPorts: (token: string) => number[];
   /** The pid of the process listening on a port of this engine, where a guest process is: `/proc`'s socket owner. */
   portPid: (port: number) => number | undefined;
+  /** The stream handles the processes of other workers hold through this engine: `/proc/<pid>/fd`. */
+  streamHandles: () => NativeStreamHandleView[];
   /** Deliver a signal to the named run as another process's `kill(pid)` does; false when the run is gone. */
   signalProcess: (token: string, signal: string) => boolean;
   stopProcess: (token: string) => boolean;
@@ -224,6 +226,7 @@ export function createContainer(options?: ContainerOptions): {
       // a guest's own listener, or one this engine holds for another worker's process
       return runPid(ownerOf(listener as unknown as OwnedHandle))?.pid ?? nativeStreamOwnerPid(listener);
     },
+    streamHandles: (): NativeStreamHandleView[] => nativeStreamHandles(),
     /**
      * Deliver a signal to the named run as another process's `kill(pid)` does:
      * the guest's listeners for it run, else its default action ends the run.

package/src/native-stream-owner.ts

@@ -41,6 +41,12 @@ export interface NativeStreamTransport {
 type NativeHandle = TCP | Pipe;
 interface Entry { handle: NativeHandle; descriptor: NativeStreamDescriptor; buffer?: Uint8Array }
 const scopes = new WeakMap<LibuvStreamWrap, NativeStreamScope>();
+// Every scope not yet disposed: what the container's /proc lists as each
+// process's descriptors.
+const liveScopes = new Set<NativeStreamScope>();
+
+/** One open stream handle, as a process's descriptor table shows it. */
+export interface NativeStreamHandleView { pid?: number; id: number; kind: 'tcp' | 'pipe'; listening: boolean }
 
 /**
  * One capability namespace per worker. Only the trusted host can inherit a
@@ -66,6 +72,16 @@ export class NativeStreamScope {
       || limits.maxReadChunkBytes > limits.maxQueuedBytes
       || limits.maxReadChunkBytes > limits.maxPendingWriteBytes) throw new Error('Invalid native stream resource limits.');
     this.limits = Object.freeze({ ...limits });
+    liveScopes.add(this);
+  }
+
+  /** This scope's open handles, with the process it serves. */
+  handles(): NativeStreamHandleView[] {
+    if (this.disposed) return [];
+    const pid = this.ownerPid?.();
+    return [...this.entries.values()].map(({ handle, descriptor }) => ({
+      ...(pid !== undefined ? { pid } : {}), id: descriptor.id, kind: descriptor.kind, listening: !!handle.listening,
+    }));
   }
 
   private entry(id: number): Entry | undefined {
@@ -318,6 +334,7 @@ export class NativeStreamScope {
   dispose(): void {
     if (this.disposed) return;
     this.disposed = true;
+    liveScopes.delete(this);
     const failures: unknown[] = [];
     for (const id of [...this.entries.keys()]) {
       try { this.close(id); } catch (cause) { failures.push(cause); }
@@ -330,3 +347,8 @@ export class NativeStreamScope {
 export function nativeStreamOwnerPid(handle: object): number | undefined {
   return scopes.get(handle as NativeHandle)?.ownerPid?.();
 }
+
+/** Every open native stream handle in this worker, by the process each scope serves. */
+export function nativeStreamHandles(): NativeStreamHandleView[] {
+  return [...liveScopes].flatMap(scope => scope.handles());
+}

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;
     }
@@ -909,7 +928,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(); }
     }
   }