@volter/tabnode 0.5.9 → 0.5.10

package/dist/assets/{runtime-worker-CezP_cM0.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);
@@ -26661,11 +26654,13 @@ function createProcessStream(isWritable, writeImpl) {
       return stream;
     },
     // Default write implementation (no-op for readable streams)
-    write(_data, _encoding, callback) {
+    write(_data, ...rest) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return true;
     },
-    end(_data, callback) {
+    end(...rest) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
     },
     pipe(destination) {
@@ -26681,14 +26676,31 @@ function createProcessStream(isWritable, writeImpl) {
     }
   };
   if (writeImpl) {
-    stream.write = (data2, _encoding, callback) => {
-      const result = writeImpl(typeof data2 === "string" ? data2 : data2.toString());
+    stream.write = (data2, ...rest) => {
+      const result = writeImpl(textOf(data2));
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return result;
     };
+    stream.end = (...args) => {
+      const data2 = args[0];
+      if (typeof data2 === "string" || data2 instanceof Uint8Array) writeImpl(textOf(data2));
+      const callback = trailingCallback(args);
+      if (callback) queueMicrotask(callback);
+    };
   }
   return stream;
 }
+function textOf(data2) {
+  return typeof data2 === "string" ? data2 : new TextDecoder().decode(data2);
+}
+function trailingCallback(args) {
+  for (let index2 = args.length - 1; index2 >= 0; index2 -= 1) {
+    const value = args[index2];
+    if (typeof value === "function") return value;
+  }
+  return void 0;
+}
 const __substrateSignals = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGILL: 4, SIGTRAP: 5, SIGABRT: 6, SIGBUS: 7, SIGFPE: 8, SIGKILL: 9, SIGUSR1: 10, SIGSEGV: 11, SIGUSR2: 12, SIGPIPE: 13, SIGALRM: 14, SIGTERM: 15, SIGCHLD: 17, SIGCONT: 18, SIGSTOP: 19, SIGTSTP: 20, SIGTTIN: 21, SIGTTOU: 22, SIGURG: 23, SIGWINCH: 28 };
 const __substrateSignalNames = Object.fromEntries(Object.entries(__substrateSignals).map(([name, number]) => [number, name]));
 const __substrateBindingWarned = /* @__PURE__ */ new WeakSet();

package/dist/http-client-transport.d.ts

@@ -15,5 +15,13 @@ export interface HttpClientExchangeResponse {
 export type HttpClientExchange = (request: HttpClientExchangeRequest) => Promise<HttpClientExchangeResponse>;
 /** Capture process attribution synchronously when the connection is requested. */
 export type HttpClientTransportFactory = () => HttpClientExchange;
+export interface HttpClientTransportOptions {
+    /**
+     * Loopback ports the host itself serves (a service of the page, not a
+     * guest's listener). Plain HTTP to one of them goes through the host
+     * exchange; every other loopback port stays the engine's own network.
+     */
+    hostPorts?: () => ReadonlySet<number>;
+}
 /** Host-only installation; guest modules receive Node's normal exports. */
-export declare function installHttpClientTransport(factory: HttpClientTransportFactory): () => void;
+export declare function installHttpClientTransport(factory: HttpClientTransportFactory, transportOptions?: HttpClientTransportOptions): () => void;

package/dist/index.d.ts

@@ -20,7 +20,7 @@ export { createProcess } from './shims/process';
 export type { Process, ProcessEnv } from './shims/process';
 export * as path from './shims/path';
 export { httpModule as http, httpsModule as https } from './node-lib/http-module';
-export { installHttpClientTransport } from './http-client-transport';
+export { installHttpClientTransport, type HttpClientTransportOptions } from './http-client-transport';
 export type { HttpClientExchange, HttpClientExchangeRequest, HttpClientExchangeResponse, HttpClientTransportFactory } from './http-client-transport';
 export { netModule as net } from './node-lib/net-module';
 export { eventsModule as events } from './node-lib/events-module';

package/dist/index.mjs

@@ -26849,11 +26849,13 @@ function createProcessStream(isWritable, writeImpl) {
       return stream;
     },
     // Default write implementation (no-op for readable streams)
-    write(_data, _encoding, callback) {
+    write(_data, ...rest) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return true;
     },
-    end(_data, callback) {
+    end(...rest) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
     },
     pipe(destination) {
@@ -26869,14 +26871,31 @@ function createProcessStream(isWritable, writeImpl) {
     }
   };
   if (writeImpl) {
-    stream.write = (data2, _encoding, callback) => {
-      const result = writeImpl(typeof data2 === "string" ? data2 : data2.toString());
+    stream.write = (data2, ...rest) => {
+      const result = writeImpl(textOf(data2));
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return result;
     };
+    stream.end = (...args) => {
+      const data2 = args[0];
+      if (typeof data2 === "string" || data2 instanceof Uint8Array) writeImpl(textOf(data2));
+      const callback = trailingCallback(args);
+      if (callback) queueMicrotask(callback);
+    };
   }
   return stream;
 }
+function textOf(data2) {
+  return typeof data2 === "string" ? data2 : new TextDecoder().decode(data2);
+}
+function trailingCallback(args) {
+  for (let index2 = args.length - 1; index2 >= 0; index2 -= 1) {
+    const value = args[index2];
+    if (typeof value === "function") return value;
+  }
+  return void 0;
+}
 const __substrateSignals = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGILL: 4, SIGTRAP: 5, SIGABRT: 6, SIGBUS: 7, SIGFPE: 8, SIGKILL: 9, SIGUSR1: 10, SIGSEGV: 11, SIGUSR2: 12, SIGPIPE: 13, SIGALRM: 14, SIGTERM: 15, SIGCHLD: 17, SIGCONT: 18, SIGSTOP: 19, SIGTSTP: 20, SIGTTIN: 21, SIGTTOU: 22, SIGURG: 23, SIGWINCH: 28 };
 const __substrateSignalNames = Object.fromEntries(Object.entries(__substrateSignals).map(([name, number]) => [number, name]));
 const __substrateBindingWarned = /* @__PURE__ */ new WeakSet();
@@ -35709,7 +35728,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-CezP_cM0.js",
+        "/assets/runtime-worker-CQv8H3sj.js",
         import.meta.url
       ),
       { type: "module" }
@@ -35927,7 +35946,7 @@ class DuplexStreamHandle extends LibuvStreamWrap {
 const unsupported = (detail) => Object.assign(new Error(`HTTP transport does not support ${detail}.`), { code: "ERR_HTTP_TRANSPORT_UNSUPPORTED" });
 const local = (host2) => host2 === "localhost" || host2 === "::1" || host2 === "[::1]" || /^127\./u.test(host2);
 const tlsOptions = ["ca", "cert", "key", "pfx", "passphrase", "ciphers", "secureContext", "checkServerIdentity", "minVersion", "maxVersion", "secureProtocol", "secureOptions", "session", "ALPNProtocols", "pskCallback"];
-function installHttpClientTransport(factory) {
+function installHttpClientTransport(factory, transportOptions = {}) {
   const installed2 = /* @__PURE__ */ new WeakMap();
   const live = /* @__PURE__ */ new Set();
   const collected = new FinalizationRegistry((ref2) => live.delete(ref2));
@@ -35936,8 +35955,11 @@ function installHttpClientTransport(factory) {
     if (installed2.has(prototype)) return;
     const original = prototype.createConnection;
     const connect2 = function(options, callback) {
+      var _a2;
       const host2 = String(options.hostname ?? options.host ?? "localhost").toLowerCase();
-      if (protocol === "http:" && (local(host2) || options.socketPath)) return original.call(this, options, callback);
+      if (protocol === "http:" && (local(host2) || options.socketPath) && !(local(host2) && !options.socketPath && ((_a2 = transportOptions.hostPorts) == null ? void 0 : _a2.call(transportOptions).has(Number(options.port ?? 80))))) {
+        return original.call(this, options, callback);
+      }
       try {
         if (options.socketPath || options.localAddress || options.localPort || options.lookup || options.family) throw unsupported("custom socket routing");
         if (tlsOptions.some((key) => options[key] !== void 0) || options.rejectUnauthorized === false || options.servername !== void 0 && options.servername !== host2) throw unsupported("custom TLS options");

package/dist/shims/process.d.ts

@@ -42,8 +42,8 @@ interface ProcessStream {
     getColorDepth: () => number;
 }
 interface ProcessWritableStream extends ProcessStream {
-    write: (data: string | Buffer, encoding?: string, callback?: () => void) => boolean;
-    end?: (data?: string, callback?: () => void) => void;
+    write: (data: string | Buffer, ...rest: unknown[]) => boolean;
+    end?: (...args: unknown[]) => void;
 }
 /**
  * `process.stdin` is a readable stream on Node -- a `net.Socket` when fd 0 is

package/package.json

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

package/src/http-client-transport.ts

@@ -33,8 +33,17 @@ const unsupported = (detail: string): Error => Object.assign(new Error(`HTTP tra
 const local = (host: string): boolean => host === 'localhost' || host === '::1' || host === '[::1]' || /^127\./u.test(host);
 const tlsOptions = ['ca', 'cert', 'key', 'pfx', 'passphrase', 'ciphers', 'secureContext', 'checkServerIdentity', 'minVersion', 'maxVersion', 'secureProtocol', 'secureOptions', 'session', 'ALPNProtocols', 'pskCallback'];
 
+export interface HttpClientTransportOptions {
+  /**
+   * Loopback ports the host itself serves (a service of the page, not a
+   * guest's listener). Plain HTTP to one of them goes through the host
+   * exchange; every other loopback port stays the engine's own network.
+   */
+  hostPorts?: () => ReadonlySet<number>;
+}
+
 /** Host-only installation; guest modules receive Node's normal exports. */
-export function installHttpClientTransport(factory: HttpClientTransportFactory): () => void {
+export function installHttpClientTransport(factory: HttpClientTransportFactory, transportOptions: HttpClientTransportOptions = {}): () => void {
   type AgentPrototype = { createConnection: (...args: any[]) => any };
   const installed = new WeakMap<AgentPrototype, { original: AgentPrototype['createConnection']; connect: AgentPrototype['createConnection'] }>();
   const live = new Set<WeakRef<AgentPrototype>>();
@@ -45,8 +54,11 @@ export function installHttpClientTransport(factory: HttpClientTransportFactory):
     const original = prototype.createConnection;
     const connect = function(this: unknown, options: Record<string, any>, callback: (error: Error | null, socket?: unknown) => void): unknown {
       const host = String(options.hostname ?? options.host ?? 'localhost').toLowerCase();
-      // Plain local HTTP is the engine's existing virtual network.
-      if (protocol === 'http:' && (local(host) || options.socketPath)) return original.call(this, options, callback);
+      // Plain local HTTP is the engine's existing virtual network, except a port the host serves itself.
+      if (protocol === 'http:' && (local(host) || options.socketPath)
+        && !(local(host) && !options.socketPath && transportOptions.hostPorts?.().has(Number(options.port ?? 80)))) {
+        return original.call(this, options, callback);
+      }
       try {
         if (options.socketPath || options.localAddress || options.localPort || options.lookup || options.family) throw unsupported('custom socket routing');
         if (tlsOptions.some(key => options[key] !== undefined) || options.rejectUnauthorized === false

package/src/index.ts

@@ -24,7 +24,7 @@ export { createProcess } from './shims/process';
 export type { Process, ProcessEnv } from './shims/process';
 export * as path from './shims/path';
 export { httpModule as http, httpsModule as https } from './node-lib/http-module';
-export { installHttpClientTransport } from './http-client-transport';
+export { installHttpClientTransport, type HttpClientTransportOptions } from './http-client-transport';
 export type { HttpClientExchange, HttpClientExchangeRequest, HttpClientExchangeResponse, HttpClientTransportFactory } from './http-client-transport';
 import { __releaseOwnedServers, __ownedServerPorts } from './node-lib/net-module';
 export { netModule as net } from './node-lib/net-module';

package/src/shims/process.ts

@@ -60,8 +60,8 @@ interface ProcessStream {
 }
 
 interface ProcessWritableStream extends ProcessStream {
-  write: (data: string | Buffer, encoding?: string, callback?: () => void) => boolean;
-  end?: (data?: string, callback?: () => void) => void;
+  write: (data: string | Buffer, ...rest: unknown[]) => boolean;
+  end?: (...args: unknown[]) => void;
 }
 
 /**
@@ -302,11 +302,13 @@ function createProcessStream(
       return stream;
     },
     // Default write implementation (no-op for readable streams)
-    write(_data: string | Buffer, _encoding?: string, callback?: () => void) {
+    write(_data: string | Buffer, ...rest: unknown[]) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return true;
     },
-    end(_data?: string, callback?: () => void) {
+    end(...rest: unknown[]) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
     },
     pipe(destination: unknown) {
@@ -324,16 +326,42 @@ function createProcessStream(
 
   // Override write for actual writable streams
   if (isWritable && writeImpl) {
-    stream.write = (data: string | Buffer, _encoding?: string, callback?: () => void) => {
-      const result = writeImpl(typeof data === 'string' ? data : data.toString());
+    stream.write = (data: string | Buffer, ...rest: unknown[]) => {
+      const result = writeImpl(textOf(data));
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return result;
     };
+    stream.end = (...args: unknown[]) => {
+      const data = args[0];
+      if (typeof data === 'string' || data instanceof Uint8Array) writeImpl(textOf(data));
+      const callback = trailingCallback(args);
+      if (callback) queueMicrotask(callback);
+    };
   }
 
   return stream;
 }
 
+/** A chunk's text: bytes, a Buffer's or a plain Uint8Array's, are UTF-8. */
+function textOf(data: string | Uint8Array): string {
+  return typeof data === 'string' ? data : new TextDecoder().decode(data);
+}
+
+/**
+ * Node's `write(chunk[, encoding][, callback])` and `end([chunk][, encoding][, callback])`:
+ * the callback is whichever argument is a function. `stdout.write('', done)`
+ * is how a program waits for its output to be flushed before it exits, and a
+ * callback read only from the third place never ran.
+ */
+function trailingCallback(args: readonly unknown[]): (() => void) | undefined {
+  for (let index = args.length - 1; index >= 0; index -= 1) {
+    const value = args[index];
+    if (typeof value === 'function') return value as () => void;
+  }
+  return undefined;
+}
+
 /** The signal numbers a guest sees, and the signals a tab must ignore. */
 const __substrateSignals: Record<string, number> = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGILL: 4, SIGTRAP: 5, SIGABRT: 6, SIGBUS: 7, SIGFPE: 8, SIGKILL: 9, SIGUSR1: 10, SIGSEGV: 11, SIGUSR2: 12, SIGPIPE: 13, SIGALRM: 14, SIGTERM: 15, SIGCHLD: 17, SIGCONT: 18, SIGSTOP: 19, SIGTSTP: 20, SIGTTIN: 21, SIGTTOU: 22, SIGURG: 23, SIGWINCH: 28 };
 const __substrateSignalNames: Record<number, string> = Object.fromEntries(Object.entries(__substrateSignals).map(([name, number]) => [number, name]));