@volter/tabnode 0.5.1 → 0.5.3

package/dist/assets/{runtime-worker-DBZ2flHK.js → runtime-worker-CfmZOVKz.js}

@@ -27126,6 +27126,16 @@ function nodeLibPublic(name, require2, _process) {
   });
   return __table[name];
 }
+const stackOverrides = /* @__PURE__ */ new Map();
+const stackOverrideMap = {
+  set(error, override) {
+    stackOverrides.set(error, override);
+    return this;
+  },
+  get: (error) => stackOverrides.get(error),
+  has: (error) => stackOverrides.has(error),
+  delete: (error) => stackOverrides.delete(error)
+};
 var builtPrimordials;
 function primordialsOf() {
   if (builtPrimordials === void 0) {
@@ -27403,6 +27413,11 @@ function bootstrapNodeLib(name, exports$1, process2) {
     };
     return;
   }
+  if (name === "internal/errors") {
+    const map = exports$1.overrideStackTrace;
+    for (const [key, value] of Object.entries(stackOverrideMap)) Object.defineProperty(map, key, { value, configurable: true });
+    return;
+  }
   if (name === "internal/util/debuglog") {
     const env = process2.env;
     (_a3 = exports$1.initializeDebugEnv) == null ? void 0 : _a3.call(exports$1, (env == null ? void 0 : env.NODE_DEBUG) ?? "");
@@ -75824,7 +75839,17 @@ function __substrateCallSiteFileNames() {
     }
     return namer;
   };
-  const get2 = () => typeof guestPrepare === "function" ? namerFor(guestPrepare) : guestPrepare;
+  const overriding = (error, sites) => {
+    const override = error !== null && typeof error === "object" ? stackOverrides.get(error) : void 0;
+    if (override) {
+      stackOverrides.delete(error);
+      return override(error, sites.map(named));
+    }
+    if (typeof guestPrepare === "function") return namerFor(guestPrepare)(error, sites);
+    return `${Error.prototype.toString.call(error)}${sites.map((site) => `
+    at ${String(site)}`).join("")}`;
+  };
+  const get2 = () => stackOverrides.size > 0 ? overriding : typeof guestPrepare === "function" ? namerFor(guestPrepare) : guestPrepare;
   get2.__substrateNamesFrames = true;
   defineOnHost(Error, "prepareStackTrace", {
     get: get2,

package/dist/index.mjs

@@ -17762,10 +17762,17 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply = Function.prototype.apply;
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = functionApply;
+var $apply$1 = requireFunctionApply();
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -17885,7 +17892,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = functionApply;
+var $apply = requireFunctionApply();
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -18526,7 +18533,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = functionApply;
+  var $apply2 = requireFunctionApply();
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -27286,6 +27293,16 @@ function nodeLibPublic(name, require2, _process) {
   });
   return __table[name];
 }
+const stackOverrides = /* @__PURE__ */ new Map();
+const stackOverrideMap = {
+  set(error, override) {
+    stackOverrides.set(error, override);
+    return this;
+  },
+  get: (error) => stackOverrides.get(error),
+  has: (error) => stackOverrides.has(error),
+  delete: (error) => stackOverrides.delete(error)
+};
 var builtPrimordials;
 function primordialsOf() {
   if (builtPrimordials === void 0) {
@@ -27569,6 +27586,11 @@ function bootstrapNodeLib(name, exports$1, process2) {
     };
     return;
   }
+  if (name === "internal/errors") {
+    const map = exports$1.overrideStackTrace;
+    for (const [key, value] of Object.entries(stackOverrideMap)) Object.defineProperty(map, key, { value, configurable: true });
+    return;
+  }
   if (name === "internal/util/debuglog") {
     const env = process2.env;
     (_a2 = exports$1.initializeDebugEnv) == null ? void 0 : _a2.call(exports$1, (env == null ? void 0 : env.NODE_DEBUG) ?? "");
@@ -35498,7 +35520,17 @@ function __substrateCallSiteFileNames() {
     }
     return namer;
   };
-  const get2 = () => typeof guestPrepare === "function" ? namerFor(guestPrepare) : guestPrepare;
+  const overriding = (error, sites) => {
+    const override = error !== null && typeof error === "object" ? stackOverrides.get(error) : void 0;
+    if (override) {
+      stackOverrides.delete(error);
+      return override(error, sites.map(named));
+    }
+    if (typeof guestPrepare === "function") return namerFor(guestPrepare)(error, sites);
+    return `${Error.prototype.toString.call(error)}${sites.map((site) => `
+    at ${String(site)}`).join("")}`;
+  };
+  const get2 = () => stackOverrides.size > 0 ? overriding : typeof guestPrepare === "function" ? namerFor(guestPrepare) : guestPrepare;
   get2.__substrateNamesFrames = true;
   defineOnHost(Error, "prepareStackTrace", {
     get: get2,
@@ -35523,7 +35555,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-DBZ2flHK.js",
+        "/assets/runtime-worker-CfmZOVKz.js",
         import.meta.url
       ),
       { type: "module" }
@@ -37383,11 +37415,15 @@ function __substrateListenForUpgrades(bridge) {
       const key = uint8ToBase64(crypto.getRandomValues(new Uint8Array(16)));
       const protocols = Array.isArray(data2.protocols) ? data2.protocols : [];
       void __upgradeOverLoopback(port, "GET", url2.pathname + url2.search, {
-        Host: url2.host,
+        // Host is the authority the client addressed, as an HTTP request's is
+        Host: typeof data2.host === "string" && /^(?:\[[0-9a-f:.]+\]|[a-z0-9.-]+)(?::[0-9]{1,5})?$/iu.test(data2.host) ? data2.host : url2.host,
         Upgrade: "websocket",
         "Sec-WebSocket-Version": "13",
         "Sec-WebSocket-Key": key,
-        ...protocols.length ? { "Sec-WebSocket-Protocol": protocols.join(", ") } : {}
+        ...protocols.length ? { "Sec-WebSocket-Protocol": protocols.join(", ") } : {},
+        // A browser sends Origin on every WebSocket handshake, and a server's
+        // check of it is how it refuses sockets from pages it did not serve.
+        ...typeof data2.origin === "string" && /^https?:\/\/[^/]+$/u.test(data2.origin) ? { Origin: data2.origin } : {}
       }).then((result) => {
         if (result.statusCode !== 101 || !result.socket) {
           channel.postMessage({ type: "close", targetClient: data2.clientId, code: 1006, reason: "upgrade refused" });

package/dist/stack-overrides.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Node's `overrideStackTrace`, as the realm's stack hook reads it.
+ *
+ * Node's files format a stack their own way by putting a function for one
+ * error in `internal/errors`' `overrideStackTrace` and reading `error.stack`:
+ * `assert.ok` takes its caller's call site that way. V8 hands that function
+ * the call sites because Node's bootstrap registers `prepareStackTraceCallback`
+ * with it, and that callback reads the map first. The engine has no such
+ * registration; `Error.prepareStackTrace` is the door it has. Every process's
+ * `internal/errors` writes here, and the realm's hook reads here, so the
+ * override reaches V8 whichever process set it. An entry is consumed by the
+ * stack it formats, as Node's is.
+ */
+export type StackOverride = (error: unknown, sites: unknown[]) => unknown;
+export declare const stackOverrides: Map<object, StackOverride>;
+/** A WeakMap-shaped view of the table, which is what `internal/errors` holds. */
+export declare const stackOverrideMap: {
+    set(this: object, error: object, override: StackOverride): object;
+    get: (error: object) => StackOverride | undefined;
+    has: (error: object) => boolean;
+    delete: (error: object) => boolean;
+};

package/package.json

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

package/src/node-lib/load.ts

@@ -31,6 +31,7 @@ import { setLibRequire } from './require-hook';
 import { NODE_LTS_VERSION, nodeVersions } from './node-versions';
 import { createUtilBinding } from './binding/util';
 import { createFsBindings } from './binding/fs';
+import { stackOverrideMap } from '../stack-overrides';
 
 /**
  * The realm's built-ins, captured as Node captures them: before a program can
@@ -445,6 +446,19 @@ function bootstrapNodeLib(name: string, exports: unknown, process: object): void
     };
     return;
   }
+  if (name === 'internal/errors') {
+    // Node's bootstrap registers this file's `prepareStackTraceCallback` with
+    // V8, which reads `overrideStackTrace` before anything else formats a
+    // stack. Here the realm's `Error.prepareStackTrace` hook is that reader,
+    // so the map is the one it reads (`src/stack-overrides.ts`). Unread, an
+    // `assert.ok(false)` indexed the stack's text for a call site and threw
+    // `TypeError: call.getFileName is not a function`.
+    // A primordial map's prototype is frozen, so its methods are shadowed by
+    // definition rather than assignment.
+    const map = (exports as { overrideStackTrace: object }).overrideStackTrace;
+    for (const [key, value] of Object.entries(stackOverrideMap)) Object.defineProperty(map, key, { value, configurable: true });
+    return;
+  }
   if (name === 'internal/util/debuglog') {
     const env = (process as { env?: Record<string, string | undefined> }).env;
     (exports as { initializeDebugEnv?: (value: string) => void }).initializeDebugEnv?.(env?.NODE_DEBUG ?? '');

package/src/runtime.ts

@@ -24,6 +24,7 @@ import { netModule as netShim } from './node-lib/net-module';
 import { errname as __uvErrname } from './node-lib/binding/uv';
 import { createTimersModule } from './node-lib/timers';
 import { guestTimerFunctions } from './guest-timers';
+import { stackOverrides } from './stack-overrides';
 export { pendingGuestTimers, stopGuestTimers } from './guest-timers';
 import eventsShim from './node-lib/events-module';
 import { streamModule as streamShim, streamPromisesModule as streamPromises } from './node-lib/stream-module';
@@ -2936,7 +2937,19 @@ function __substrateCallSiteFileNames(): void {
     }
     return namer;
   };
-  const get = () => (typeof guestPrepare === 'function' ? namerFor(guestPrepare as Prepare) : guestPrepare);
+  // While one of Node's own files has an override pending for a stack it is
+  // about to read, V8 is handed a function that gives that error its
+  // override and every other error what it would have had: the guest's
+  // function, else V8's own text, which is the error and one `at` line
+  // per call site. Otherwise V8 is handed exactly what the guest set.
+  const overriding: Prepare = (error, sites) => {
+    const override = error !== null && typeof error === 'object' ? stackOverrides.get(error) : undefined;
+    if (override) { stackOverrides.delete(error as object); return override(error, sites.map(named)); }
+    if (typeof guestPrepare === 'function') return namerFor(guestPrepare as Prepare)(error, sites);
+    return `${Error.prototype.toString.call(error)}${sites.map(site => `\n    at ${String(site)}`).join('')}`;
+  };
+  const get = () => (stackOverrides.size > 0 ? overriding
+    : typeof guestPrepare === 'function' ? namerFor(guestPrepare as Prepare) : guestPrepare);
   (get as { __substrateNamesFrames?: boolean }).__substrateNamesFrames = true;
   defineOnHost(Error, 'prepareStackTrace', {
     get,

package/src/server-bridge.ts

@@ -123,6 +123,10 @@ interface UpgradeSignal {
   protocols?: string[];
   /** `"none"` asks for a byte pipe; anything else, or nothing, is a WebSocket. */
   framing?: "websocket" | "none";
+  /** The origin of the page that opened the socket, which a browser sends on every handshake. */
+  origin?: string;
+  /** The authority the client addressed, its handshake's Host; the engine's own URL names the port. */
+  host?: string;
   payload?: string | ArrayBuffer;
   code?: number;
   reason?: string;
@@ -348,11 +352,15 @@ function __substrateListenForUpgrades(bridge: ServerBridge): BroadcastChannel |
       // with the socket, which is what the real `ws` takes over. What comes
       // back here is the client's end of that same connection.
       void __upgradeOverLoopback(port, "GET", url2.pathname + url2.search, {
-        Host: url2.host,
+        // Host is the authority the client addressed, as an HTTP request's is
+        Host: typeof data2.host === "string" && /^(?:\[[0-9a-f:.]+\]|[a-z0-9.-]+)(?::[0-9]{1,5})?$/iu.test(data2.host) ? data2.host : url2.host,
         Upgrade: "websocket",
         "Sec-WebSocket-Version": "13",
         "Sec-WebSocket-Key": key,
         ...(protocols.length ? { "Sec-WebSocket-Protocol": protocols.join(", ") } : {}),
+        // A browser sends Origin on every WebSocket handshake, and a server's
+        // check of it is how it refuses sockets from pages it did not serve.
+        ...(typeof data2.origin === "string" && /^https?:\/\/[^/]+$/u.test(data2.origin) ? { Origin: data2.origin } : {}),
       }).then((result) => {
         if (result.statusCode !== 101 || !result.socket) {
           channel.postMessage({ type: "close", targetClient: data2.clientId, code: 1006, reason: "upgrade refused" });

package/src/stack-overrides.ts

@@ -0,0 +1,24 @@
+/**
+ * Node's `overrideStackTrace`, as the realm's stack hook reads it.
+ *
+ * Node's files format a stack their own way by putting a function for one
+ * error in `internal/errors`' `overrideStackTrace` and reading `error.stack`:
+ * `assert.ok` takes its caller's call site that way. V8 hands that function
+ * the call sites because Node's bootstrap registers `prepareStackTraceCallback`
+ * with it, and that callback reads the map first. The engine has no such
+ * registration; `Error.prepareStackTrace` is the door it has. Every process's
+ * `internal/errors` writes here, and the realm's hook reads here, so the
+ * override reaches V8 whichever process set it. An entry is consumed by the
+ * stack it formats, as Node's is.
+ */
+export type StackOverride = (error: unknown, sites: unknown[]) => unknown;
+
+export const stackOverrides = new Map<object, StackOverride>();
+
+/** A WeakMap-shaped view of the table, which is what `internal/errors` holds. */
+export const stackOverrideMap = {
+  set(this: object, error: object, override: StackOverride) { stackOverrides.set(error, override); return this; },
+  get: (error: object) => stackOverrides.get(error),
+  has: (error: object) => stackOverrides.has(error),
+  delete: (error: object) => stackOverrides.delete(error),
+};