@volter/tabnode 0.5.50 → 0.5.51

package/dist/__sw__.js

@@ -99,6 +99,16 @@ let requestId = 0;
 const controlledUploads = new Set();
 const MAX_STREAM_CHUNK_BYTES = 65536;
 
+// A response chunk as the host sent it: its bytes, transferred, from a bridge this worker told it
+// takes them (`sw-capabilities`), or base64 from one that predates that. Base64 cost the page's
+// own thread an encode of every byte a virtual server sent (5.4 s of 46 while a 307 MB document
+// crossed, measured in the hosted model editor) and left a third more garbage than the bytes.
+function chunkBytes(data) {
+  if (data?.chunk instanceof Uint8Array) return data.chunk;
+  if (typeof data?.chunkBase64 === 'string') return base64ToBytes(data.chunkBase64);
+  return null;
+}
+
 function updateFlowControl(host, type, data) {
   if (type === 'server-registered' || type === 'server-unregistered') {
     for (const upload of controlledUploads) {
@@ -157,6 +167,7 @@ self.addEventListener('message', (event) => {
     mainPort.onmessage = (message) => {
       if (hosts.get(host.id) === host && host.port === initializedPort) handleMainMessage(host, message);
     };
+    mainPort.postMessage({ type: 'sw-capabilities', data: { binaryChunks: 1 } });
     if (data && Array.isArray(data.ownDocuments)) host.ownDocuments = new Set(data.ownDocuments.map((path) => ownPath(String(path))));
     // Markup a frame's document served from this host's servers starts with
     // (after its doctype): the page's first script, before the document's own.
@@ -257,9 +268,8 @@ function handleMainMessage(host, event) {
     const pending = pendingRequests.get(id);
     if (pending && pending.streamController) {
       try {
-        // Decode base64 chunk and enqueue
-        if (data.chunkBase64) {
-          const bytes = base64ToBytes(data.chunkBase64);
+        const bytes = chunkBytes(data);
+        if (bytes && bytes.byteLength > 0) {
           pending.streamController.enqueue(bytes);
           DEBUG && console.log('[SW] chunk enqueued, bytes:', bytes.length);
         }
@@ -428,10 +438,11 @@ async function sendControlledRequest(host, port, method, url, headers, body, sig
           clearTimeout(headerTimeout);
           resolveHeaders(data);
         } else if (type === 'stream-chunk' && headed && credited) {
-          if (typeof data?.chunkBase64 !== 'string'
-              || data.chunkBase64.length > Math.ceil(MAX_STREAM_CHUNK_BYTES / 3) * 4)
+          if (typeof data?.chunkBase64 === 'string'
+              && data.chunkBase64.length > Math.ceil(MAX_STREAM_CHUNK_BYTES / 3) * 4)
             throw new Error('Stream chunk exceeds transport limit');
-          const bytes = base64ToBytes(data.chunkBase64);
+          const bytes = chunkBytes(data);
+          if (!bytes) throw new Error('Stream chunk carries no bytes');
           if (bytes.byteLength > MAX_STREAM_CHUNK_BYTES)
             throw new Error('Stream chunk exceeds transport limit');
           credited = false;

package/dist/index.mjs

@@ -18,8 +18,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   }
 });
 var _a, _b, _asyncId, _triggerAsyncId, _c, _d, _e, _f, _g, _h, _i, _j, _ptr, _type, _maxHeaderSize, _headerBytes, _headers, _field, _value, _readingValue, _url, _statusMessage, _headersSent, _paused, _buffer, _bufferPtr, _bufferSize, _connections, _HTTPParser_instances, reset_fn, copyIn_fn, pushHeader_fn, countHeaderBytes_fn, _parsers, _strm, _writeState, _callback, _level, _strategy, _windowBits, _memLevel, _dictionary, _ended, _Zlib_instances, inflating_get, windowFor_fn, start_fn, fail_fn, report_fn, run_fn, end_fn, _writeState2, _callback2, _input, _output, _outputAt, _BrotliDecoderHandle_instances, run_fn2, _k, _resolveChain, _loadChain, _initializing, _initializeFailure, _RunModuleHooks_instances, run_fn3;
-import { u as uint8ToBase64, b as base64ToUint8, a as uint8ToBinaryString, c as uint8ToHex, P as PortBridge } from "./port-bridge-CixAESwA.js";
-import { g } from "./port-bridge-CixAESwA.js";
+import { u as uint8ToBase64, b as base64ToUint8, a as uint8ToBinaryString, c as uint8ToHex, P as PortBridge } from "./port-bridge-Cergvxli.js";
+import { g } from "./port-bridge-Cergvxli.js";
 import { defineCommand, Bash, getCommandNames } from "just-bash";
 import { imports, resolve as resolve$3 } from "resolve.exports";
 import { wrap, proxy } from "comlink";

package/dist/{port-bridge-CixAESwA.js → port-bridge-Cergvxli.js}

@@ -100,6 +100,11 @@ const _PortBridge = class _PortBridge extends BridgeEvents {
     /** The server the service worker answers at the origin's root, the preview's; null for none. */
     __publicField(this, "primaryPort", null);
     __publicField(this, "ownDocuments");
+    /**
+     * Handle messages from Service Worker
+     */
+    /** The channels whose worker takes a response chunk as transferred bytes (`sw-capabilities`). */
+    __publicField(this, "binaryChunkPorts", /* @__PURE__ */ new WeakSet());
     /** 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;
@@ -275,12 +280,20 @@ const _PortBridge = class _PortBridge extends BridgeEvents {
     this.announceServers();
     this.emit("sw-ready");
   }
-  /**
-   * Handle messages from Service Worker
-   */
+  /** One response chunk on `port`: its bytes transferred where the worker said it takes them,
+   *  base64 to a worker that predates that. `bytes` must be the chunk's own buffer. */
+  postChunk(port, id, bytes) {
+    if (!port) return;
+    if (this.binaryChunkPorts.has(port)) port.postMessage({ type: "stream-chunk", id, data: { chunk: bytes } }, [bytes.buffer]);
+    else port.postMessage({ type: "stream-chunk", id, data: { chunkBase64: uint8ToBase64(bytes) } });
+  }
   async handleServiceWorkerMessage(event) {
     var _a, _b, _c;
     const { type, id, data } = event.data;
+    if (type === "sw-capabilities") {
+      if ((data == null ? void 0 : data.binaryChunks) === 1 && event.target instanceof MessagePort) this.binaryChunkPorts.add(event.target);
+      return;
+    }
     _PortBridge.DEBUG && console.log("[ServerBridge] SW message:", type, id, data == null ? void 0 : data.url);
     if (type === "stream-pull" || type === "stream-cancel") {
       const stream = this.controlledStreams.get(id);
@@ -445,14 +458,9 @@ const _PortBridge = class _PortBridge extends BridgeEvents {
         // onChunk - called for each chunk
         (chunk) => {
           var _a2;
-          const bytes = typeof chunk === "string" ? _encoder.encode(chunk) : chunk;
-          const chunkBase64 = uint8ToBase64(bytes);
-          _PortBridge.DEBUG && console.log("[ServerBridge] 🟡 onChunk called, sending stream-chunk, size:", chunkBase64.length);
-          (_a2 = this.messageChannel) == null ? void 0 : _a2.port1.postMessage({
-            type: "stream-chunk",
-            id,
-            data: { chunkBase64 }
-          });
+          const bytes = typeof chunk === "string" ? _encoder.encode(chunk) : ownedBytes(chunk);
+          _PortBridge.DEBUG && console.log("[ServerBridge] 🟡 onChunk called, sending stream-chunk, size:", bytes.byteLength);
+          this.postChunk((_a2 = this.messageChannel) == null ? void 0 : _a2.port1, id, bytes);
         },
         // onEnd - called when response is complete
         () => {
@@ -474,12 +482,8 @@ const _PortBridge = class _PortBridge extends BridgeEvents {
         }
       });
       if (response.body && response.body.length > 0) {
-        const bytes = response.body instanceof Uint8Array ? response.body : new Uint8Array(0);
-        (_d = this.messageChannel) == null ? void 0 : _d.port1.postMessage({
-          type: "stream-chunk",
-          id,
-          data: { chunkBase64: uint8ToBase64(bytes) }
-        });
+        const bytes = response.body instanceof Uint8Array ? ownedBytes(response.body) : new Uint8Array(0);
+        this.postChunk((_d = this.messageChannel) == null ? void 0 : _d.port1, id, bytes);
       }
       (_e = this.messageChannel) == null ? void 0 : _e.port1.postMessage({ type: "stream-end", id });
     }
@@ -521,7 +525,7 @@ const _PortBridge = class _PortBridge extends BridgeEvents {
       if (finished) return;
       while (credits > 0 && queue.length > 0) {
         credits -= 1;
-        post("stream-chunk", { chunkBase64: uint8ToBase64(queue.shift()) });
+        this.postChunk(channel == null ? void 0 : channel.port1, id, queue.shift());
       }
       if (upstreamEnded && queue.length === 0) {
         post("stream-end");

package/dist/port-bridge.d.ts

@@ -122,6 +122,11 @@ export declare class PortBridge extends BridgeEvents {
     /**
      * Handle messages from Service Worker
      */
+    /** The channels whose worker takes a response chunk as transferred bytes (`sw-capabilities`). */
+    private readonly binaryChunkPorts;
+    /** One response chunk on `port`: its bytes transferred where the worker said it takes them,
+     *  base64 to a worker that predates that. `bytes` must be the chunk's own buffer. */
+    private postChunk;
     private handleServiceWorkerMessage;
     /**
      * Handle a streaming request - sends chunks as they arrive

package/dist/port-bridge.mjs

@@ -1,4 +1,4 @@
-import { P, g, o } from "./port-bridge-CixAESwA.js";
+import { P, g, o } from "./port-bridge-Cergvxli.js";
 export {
   P as PortBridge,
   g as getPortBridge,

package/package.json

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

package/src/port-bridge.ts

@@ -378,8 +378,23 @@ export class PortBridge extends BridgeEvents {
   /**
    * Handle messages from Service Worker
    */
+  /** The channels whose worker takes a response chunk as transferred bytes (`sw-capabilities`). */
+  private readonly binaryChunkPorts = new WeakSet<MessagePort>();
+
+  /** One response chunk on `port`: its bytes transferred where the worker said it takes them,
+   *  base64 to a worker that predates that. `bytes` must be the chunk's own buffer. */
+  private postChunk(port: MessagePort | undefined, id: number, bytes: Uint8Array): void {
+    if (!port) return;
+    if (this.binaryChunkPorts.has(port)) port.postMessage({ type: 'stream-chunk', id, data: { chunk: bytes } }, [bytes.buffer]);
+    else port.postMessage({ type: 'stream-chunk', id, data: { chunkBase64: uint8ToBase64(bytes) } });
+  }
+
   private async handleServiceWorkerMessage(event: MessageEvent): Promise<void> {
     const { type, id, data } = event.data;
+    if (type === 'sw-capabilities') {
+      if (data?.binaryChunks === 1 && event.target instanceof MessagePort) this.binaryChunkPorts.add(event.target);
+      return;
+    }
 
     PortBridge.DEBUG && console.log('[ServerBridge] SW message:', type, id, data?.url);
 
@@ -578,14 +593,9 @@ export class PortBridge extends BridgeEvents {
         },
         // onChunk - called for each chunk
         (chunk: string | Uint8Array) => {
-          const bytes = typeof chunk === 'string' ? _encoder.encode(chunk) : chunk;
-          const chunkBase64 = uint8ToBase64(bytes);
-          PortBridge.DEBUG && console.log('[ServerBridge] 🟡 onChunk called, sending stream-chunk, size:', chunkBase64.length);
-          this.messageChannel?.port1.postMessage({
-            type: 'stream-chunk',
-            id,
-            data: { chunkBase64 },
-          });
+          const bytes = typeof chunk === 'string' ? _encoder.encode(chunk) : ownedBytes(chunk);
+          PortBridge.DEBUG && console.log('[ServerBridge] 🟡 onChunk called, sending stream-chunk, size:', bytes.byteLength);
+          this.postChunk(this.messageChannel?.port1, id, bytes);
         },
         // onEnd - called when response is complete
         () => {
@@ -610,12 +620,8 @@ export class PortBridge extends BridgeEvents {
       });
 
       if (response.body && response.body.length > 0) {
-        const bytes = response.body instanceof Uint8Array ? response.body : new Uint8Array(0);
-        this.messageChannel?.port1.postMessage({
-          type: 'stream-chunk',
-          id,
-          data: { chunkBase64: uint8ToBase64(bytes) },
-        });
+        const bytes = response.body instanceof Uint8Array ? ownedBytes(response.body) : new Uint8Array(0);
+        this.postChunk(this.messageChannel?.port1, id, bytes);
       }
 
       this.messageChannel?.port1.postMessage({ type: 'stream-end', id });
@@ -664,7 +670,7 @@ export class PortBridge extends BridgeEvents {
       if (finished) return;
       while (credits > 0 && queue.length > 0) {
         credits -= 1;
-        post('stream-chunk', { chunkBase64: uint8ToBase64(queue.shift()!) });
+        this.postChunk(channel?.port1, id, 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