@volter/tabnode 0.5.49 → 0.5.51

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/dist/shims/crypto-cipher.d.ts

@@ -0,0 +1,203 @@
+import { GHASH } from '@noble/ciphers/_polyval.js';
+type Mode = 'gcm' | 'cbc' | 'ctr' | 'ecb';
+type Bytes = Uint8Array;
+export interface CipherDeps {
+    /** The guest's Buffer.from over bytes. */
+    toBuffer(bytes: Bytes): Uint8Array;
+    /** Bytes of a string (in its encoding) or a view, as the rest of crypto reads them. */
+    bytesOf(value: unknown, encoding?: string): Bytes;
+    /** A secret KeyObject's bytes, or undefined when the value is not a KeyObject. */
+    secretKeyBytes(value: unknown): Bytes | undefined;
+    /** Bytes in an output encoding, as `digest` answers them. */
+    encode(bytes: Bytes, encoding?: string): unknown;
+    error(code: string, message: string): Error;
+}
+/** The ciphers `createCipheriv` accepts, as `getCiphers` lists them. */
+export declare function cipherNames(): string[];
+export declare function createCipherClasses(deps: CipherDeps): {
+    Cipheriv: {
+        new (algorithm: unknown, key: unknown, iv: unknown, options?: {
+            authTagLength?: number;
+        }): {
+            getAuthTag(): Uint8Array;
+            readonly "__#private@#decrypt": boolean;
+            readonly "__#private@#mode": Mode;
+            readonly "__#private@#xk": Uint32Array;
+            readonly "__#private@#xkDec": Uint32Array | undefined;
+            "__#private@#padding": boolean;
+            "__#private@#finished": boolean;
+            "__#private@#started": boolean;
+            /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+            "__#private@#pending": Bytes;
+            /** CBC's chaining block. */
+            "__#private@#chain": Bytes | undefined;
+            /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+            "__#private@#counter": Bytes | undefined;
+            "__#private@#keystream": Bytes;
+            /** GCM. */
+            "__#private@#ghash": GHASH | undefined;
+            "__#private@#tagMask": Bytes | undefined;
+            "__#private@#ghashPending": Bytes;
+            "__#private@#aadLength": number;
+            "__#private@#dataLength": number;
+            "__#private@#authTagLength": number | undefined;
+            "__#private@#authTag": Bytes | undefined;
+            setAutoPadding(autoPadding?: boolean): /*elided*/ any;
+            setAAD(buffer: unknown, _options?: {
+                plaintextLength?: number;
+            }): /*elided*/ any;
+            "__#private@#getTag"(): Bytes;
+            "__#private@#setTag"(tag: unknown, encoding?: string): void;
+            update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown;
+            final(outputEncoding?: string): unknown;
+            "__#private@#process"(input: Bytes): Bytes;
+            /** XOR with the counter's keystream, carrying a partial block across calls. */
+            "__#private@#stream"(input: Bytes): Bytes;
+            /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+            "__#private@#absorb"(ciphertext: Bytes): void;
+            /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+            "__#private@#blocks"(input: Bytes): Bytes;
+            "__#private@#block"(block: Bytes): Bytes;
+            "__#private@#finish"(): Bytes;
+            "__#private@#finishGcm"(): Bytes;
+        };
+    };
+    Decipheriv: {
+        new (algorithm: unknown, key: unknown, iv: unknown, options?: {
+            authTagLength?: number;
+        }): {
+            setAuthTag(tag: unknown, encoding?: string): /*elided*/ any;
+            readonly "__#private@#decrypt": boolean;
+            readonly "__#private@#mode": Mode;
+            readonly "__#private@#xk": Uint32Array;
+            readonly "__#private@#xkDec": Uint32Array | undefined;
+            "__#private@#padding": boolean;
+            "__#private@#finished": boolean;
+            "__#private@#started": boolean;
+            /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+            "__#private@#pending": Bytes;
+            /** CBC's chaining block. */
+            "__#private@#chain": Bytes | undefined;
+            /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+            "__#private@#counter": Bytes | undefined;
+            "__#private@#keystream": Bytes;
+            /** GCM. */
+            "__#private@#ghash": GHASH | undefined;
+            "__#private@#tagMask": Bytes | undefined;
+            "__#private@#ghashPending": Bytes;
+            "__#private@#aadLength": number;
+            "__#private@#dataLength": number;
+            "__#private@#authTagLength": number | undefined;
+            "__#private@#authTag": Bytes | undefined;
+            setAutoPadding(autoPadding?: boolean): /*elided*/ any;
+            setAAD(buffer: unknown, _options?: {
+                plaintextLength?: number;
+            }): /*elided*/ any;
+            "__#private@#getTag"(): Bytes;
+            "__#private@#setTag"(tag: unknown, encoding?: string): void;
+            update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown;
+            final(outputEncoding?: string): unknown;
+            "__#private@#process"(input: Bytes): Bytes;
+            /** XOR with the counter's keystream, carrying a partial block across calls. */
+            "__#private@#stream"(input: Bytes): Bytes;
+            /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+            "__#private@#absorb"(ciphertext: Bytes): void;
+            /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+            "__#private@#blocks"(input: Bytes): Bytes;
+            "__#private@#block"(block: Bytes): Bytes;
+            "__#private@#finish"(): Bytes;
+            "__#private@#finishGcm"(): Bytes;
+        };
+    };
+    createCipheriv: (algorithm: unknown, key: unknown, iv: unknown, options?: {
+        authTagLength?: number;
+    }) => {
+        getAuthTag(): Uint8Array;
+        readonly "__#private@#decrypt": boolean;
+        readonly "__#private@#mode": Mode;
+        readonly "__#private@#xk": Uint32Array;
+        readonly "__#private@#xkDec": Uint32Array | undefined;
+        "__#private@#padding": boolean;
+        "__#private@#finished": boolean;
+        "__#private@#started": boolean;
+        /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+        "__#private@#pending": Bytes;
+        /** CBC's chaining block. */
+        "__#private@#chain": Bytes | undefined;
+        /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+        "__#private@#counter": Bytes | undefined;
+        "__#private@#keystream": Bytes;
+        /** GCM. */
+        "__#private@#ghash": GHASH | undefined;
+        "__#private@#tagMask": Bytes | undefined;
+        "__#private@#ghashPending": Bytes;
+        "__#private@#aadLength": number;
+        "__#private@#dataLength": number;
+        "__#private@#authTagLength": number | undefined;
+        "__#private@#authTag": Bytes | undefined;
+        setAutoPadding(autoPadding?: boolean): /*elided*/ any;
+        setAAD(buffer: unknown, _options?: {
+            plaintextLength?: number;
+        }): /*elided*/ any;
+        "__#private@#getTag"(): Bytes;
+        "__#private@#setTag"(tag: unknown, encoding?: string): void;
+        update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown;
+        final(outputEncoding?: string): unknown;
+        "__#private@#process"(input: Bytes): Bytes;
+        /** XOR with the counter's keystream, carrying a partial block across calls. */
+        "__#private@#stream"(input: Bytes): Bytes;
+        /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+        "__#private@#absorb"(ciphertext: Bytes): void;
+        /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+        "__#private@#blocks"(input: Bytes): Bytes;
+        "__#private@#block"(block: Bytes): Bytes;
+        "__#private@#finish"(): Bytes;
+        "__#private@#finishGcm"(): Bytes;
+    };
+    createDecipheriv: (algorithm: unknown, key: unknown, iv: unknown, options?: {
+        authTagLength?: number;
+    }) => {
+        setAuthTag(tag: unknown, encoding?: string): /*elided*/ any;
+        readonly "__#private@#decrypt": boolean;
+        readonly "__#private@#mode": Mode;
+        readonly "__#private@#xk": Uint32Array;
+        readonly "__#private@#xkDec": Uint32Array | undefined;
+        "__#private@#padding": boolean;
+        "__#private@#finished": boolean;
+        "__#private@#started": boolean;
+        /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+        "__#private@#pending": Bytes;
+        /** CBC's chaining block. */
+        "__#private@#chain": Bytes | undefined;
+        /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+        "__#private@#counter": Bytes | undefined;
+        "__#private@#keystream": Bytes;
+        /** GCM. */
+        "__#private@#ghash": GHASH | undefined;
+        "__#private@#tagMask": Bytes | undefined;
+        "__#private@#ghashPending": Bytes;
+        "__#private@#aadLength": number;
+        "__#private@#dataLength": number;
+        "__#private@#authTagLength": number | undefined;
+        "__#private@#authTag": Bytes | undefined;
+        setAutoPadding(autoPadding?: boolean): /*elided*/ any;
+        setAAD(buffer: unknown, _options?: {
+            plaintextLength?: number;
+        }): /*elided*/ any;
+        "__#private@#getTag"(): Bytes;
+        "__#private@#setTag"(tag: unknown, encoding?: string): void;
+        update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown;
+        final(outputEncoding?: string): unknown;
+        "__#private@#process"(input: Bytes): Bytes;
+        /** XOR with the counter's keystream, carrying a partial block across calls. */
+        "__#private@#stream"(input: Bytes): Bytes;
+        /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+        "__#private@#absorb"(ciphertext: Bytes): void;
+        /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+        "__#private@#blocks"(input: Bytes): Bytes;
+        "__#private@#block"(block: Bytes): Bytes;
+        "__#private@#finish"(): Bytes;
+        "__#private@#finishGcm"(): Bytes;
+    };
+};
+export {};