@volter/tabnode 0.5.0 → 0.5.2

package/dist/assets/{runtime-worker-B9buriZs.js → runtime-worker-CqG62h2U.js}

@@ -27119,6 +27119,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) {
@@ -27396,6 +27406,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) ?? "");
@@ -75817,7 +75832,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,17 +17762,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);
@@ -17892,7 +17885,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);
@@ -18533,7 +18526,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);
@@ -27293,6 +27286,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) {
@@ -27576,6 +27579,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) ?? "");
@@ -35505,7 +35513,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,
@@ -35530,7 +35548,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-B9buriZs.js",
+        "/assets/runtime-worker-CqG62h2U.js",
         import.meta.url
       ),
       { type: "module" }
@@ -38262,9 +38280,14 @@ function createContainer(options) {
     // socket handler of its own, so a guest's `net.connect` reaches it: the
     // registry a connect consults is the `net` shim's, and a server of the
     // shim's own class is what registers in it. The call answers a disposer.
+    // The listener is the page's, not a guest's: a handle opened outside any
+    // run is otherwise charged to the run launched last, which then read the
+    // page's port as its own server and ended when the page stopped listening.
+    // Sockets it accepts take its owner, so they hold no guest open either.
     listenNet: (port, onConnection) => {
       const server = new Server(onConnection);
       server.listen(port);
+      __adoptHandle(server._handle, null);
       return () => {
         server.close();
       };

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

package/src/index.ts

@@ -54,6 +54,7 @@ import { PackageManager } from './npm';
 import { ServerBridge, getServerBridge } from './server-bridge';
 import { runCommand, registerRunStreams, releaseRunStreams, sendStdin } from './shims/child_process';
 import { Server as NetServer, __releaseOwnedHandles, type Socket as NetSocket } from './node-lib/net-module';
+import { __adoptHandle, type OwnedHandle } from './node-lib/binding/handles';
 
 import { __currentProcessToken, __runFor, __stopOwnedProcess, runPid, processByPid } from './process-tokens';
 export { runPid, processByPid };
@@ -229,9 +230,14 @@ export function createContainer(options?: ContainerOptions): {
     // socket handler of its own, so a guest's `net.connect` reaches it: the
     // registry a connect consults is the `net` shim's, and a server of the
     // shim's own class is what registers in it. The call answers a disposer.
+    // The listener is the page's, not a guest's: a handle opened outside any
+    // run is otherwise charged to the run launched last, which then read the
+    // page's port as its own server and ended when the page stopped listening.
+    // Sockets it accepts take its owner, so they hold no guest open either.
     listenNet: (port: number, onConnection: (socket: NetSocket) => void) => {
       const server = new NetServer(onConnection);
       server.listen(port);
+      __adoptHandle((server as unknown as { _handle?: OwnedHandle | null })._handle, null);
       return () => { server.close(); };
     },
     createREPL: () => runtime.createREPL(),

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/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),
+};