node builtins: defer cross-module requires and load-time work

src/js/internal/assert/assertion_error.ts

@@ -1,9 +1,14 @@
 "use strict";
 
-const { inspect } = require("internal/util/inspect");
 const colors = require("internal/util/colors");
-const { validateObject } = require("internal/validators");
-const { myersDiff, printMyersDiff, printSimpleMyersDiff } = require("internal/assert/myers_diff") as typeof Internal;
+let _inspect;
+function inspect(_value, _opts) {
+  return (_inspect ??= require("internal/util/inspect").inspect).$apply(this, arguments);
+}
+let _myers;
+function myers(): typeof Internal {
+  return (_myers ??= require("internal/assert/myers_diff"));
+}
 
 const ErrorCaptureStackTrace = Error.captureStackTrace;
 const ObjectAssign = Object.assign;
@@ -110,8 +115,8 @@ function getColoredMyersDiff(actual, expected) {
   const skipped = false;
 
   // const diff = myersDiff(StringPrototypeSplit.$call(actual, ""), StringPrototypeSplit.$call(expected, ""));
-  const diff = myersDiff(actual, expected, false, false);
-  let message = printSimpleMyersDiff(diff);
+  const diff = myers().myersDiff(actual, expected, false, false);
+  let message = myers().printSimpleMyersDiff(diff);
 
   if (skipped) {
     message += "...";
@@ -220,8 +225,8 @@ function createErrDiff(actual, expected, operator, customMessage) {
     const checkCommaDisparity = actual != null && typeof actual === "object";
     let myersDiffMessage;
     try {
-      const diff = myersDiff(inspectedActual, inspectedExpected, checkCommaDisparity, true);
-      myersDiffMessage = printMyersDiff(diff);
+      const diff = myers().myersDiff(inspectedActual, inspectedExpected, checkCommaDisparity, true);
+      myersDiffMessage = myers().printMyersDiff(diff);
     } catch {
       myersDiffMessage = undefined;
     }
@@ -263,7 +268,7 @@ class AssertionError extends Error {
   operator;
 
   constructor(options) {
-    validateObject(options, "options");
+    require("internal/validators").validateObject(options, "options");
     const {
       message,
       operator,
@@ -415,7 +420,7 @@ class AssertionError extends Error {
     return `${this.name} [${this.code}]: ${this.message}`;
   }
 
-  [inspect.custom](recurseTimes, ctx) {
+  [Symbol.for("nodejs.util.inspect.custom")](recurseTimes, ctx) {
     // Long strings should not be fully inspected.
     const tmpActual = this.actual;
     const tmpExpected = this.expected;

src/js/internal/cluster/child.ts

@@ -1,6 +1,5 @@
 const EventEmitter = require("node:events");
 const Worker = require("internal/cluster/Worker");
-const path = require("node:path");
 
 const sendHelper = $newRustFunction("node_cluster_binding.rs", "sendHelperChild", 3);
 const onInternalMessage = $newRustFunction("node_cluster_binding.rs", "onInternalMessageChild", 2);
@@ -62,7 +61,8 @@ cluster._getServer = function (obj, options, cb) {
   let address = options.address;
 
   // Resolve unix socket paths to absolute paths
-  if (options.port < 0 && typeof address === "string" && process.platform !== "win32") address = path.resolve(address);
+  if (options.port < 0 && typeof address === "string" && process.platform !== "win32")
+    address = require("node:path").resolve(address);
 
   const indexesKey = ArrayPrototypeJoin.$call([address, options.port, options.addressType, options.fd], ":");
 

src/js/internal/cluster/primary.ts

@@ -1,9 +1,6 @@
 const EventEmitter = require("node:events");
 const Worker = require("internal/cluster/Worker");
-const RoundRobinHandle = require("internal/cluster/RoundRobinHandle");
-const SharedHandle = require("internal/cluster/SharedHandle");
-const path = require("node:path");
-const { throwNotImplemented, kHandle } = require("internal/shared");
+const { kHandle } = require("internal/shared");
 
 const sendHelper = $newRustFunction("node_cluster_binding.rs", "sendHelperPrimary", 4);
 const onInternalMessage = $newRustFunction("node_cluster_binding.rs", "onInternalMessagePrimary", 3);
@@ -240,7 +237,7 @@ function queryServer(worker, message) {
 
     // Find shortest path for unix sockets because of the ~100 byte limit
     if (message.port < 0 && typeof address === "string" && process.platform !== "win32") {
-      address = path.relative(process.cwd(), address);
+      address = require("node:path").relative(process.cwd(), address);
 
       if (message.address.length < address.length) address = message.address;
     }
@@ -260,11 +257,11 @@ function queryServer(worker, message) {
         worker.emit("error", error);
         return;
       }
-      handle = new SharedHandle(key, address, message);
+      handle = new (require("internal/cluster/SharedHandle"))(key, address, message);
     } else if (schedulingPolicy !== SCHED_RR) {
-      throwNotImplemented("node:cluster SCHED_NONE");
+      require("internal/shared").throwNotImplemented("node:cluster SCHED_NONE");
     } else {
-      handle = new RoundRobinHandle(key, address, message);
+      handle = new (require("internal/cluster/RoundRobinHandle"))(key, address, message);
     }
 
     handles.set(key, handle);

src/js/internal/errors.ts

@@ -1,5 +1,3 @@
-const { SafeArrayIterator } = require("internal/primordials");
-
 const ArrayIsArray = Array.isArray;
 const ArrayPrototypePush = Array.prototype.push;
 
@@ -11,6 +9,7 @@ function aggregateTwoErrors(innerError: Error | undefined, outerError: Error & {
       ArrayPrototypePush.$call(outerErrors, innerError);
       return outerError;
     }
+    const { SafeArrayIterator } = require("internal/primordials");
     const err = new AggregateError(new SafeArrayIterator([outerError, innerError]), outerError.message);
     err.code = outerError.code;
     return err;

src/js/internal/fs/streams.ts

@@ -3,12 +3,21 @@ import type { FileSink } from "bun";
 const { Readable, Writable, finished } = require("node:stream");
 const fs: typeof import("node:fs") = require("node:fs");
 const { read, write, fsync, writev } = fs;
-const { FileHandle, kRef, kUnref, kFd } = (fs.promises as any).$data as {
-  FileHandle: { new (): FileHandle };
-  readonly kRef: unique symbol;
-  readonly kUnref: unique symbol;
-  readonly kFd: unique symbol;
-};
+let FileHandle: { new (): FileHandle };
+let kRef, kUnref, kFd;
+let fileHandlePrototypeRead, fileHandlePrototypeWrite, fileHandlePrototypeFsync, fileHandlePrototypeWritev;
+function loadFileHandle() {
+  if (FileHandle === undefined) {
+    ({ FileHandle, kRef, kUnref, kFd } = (require("node:fs/promises") as any).$data);
+    ({
+      read: fileHandlePrototypeRead,
+      write: fileHandlePrototypeWrite,
+      fsync: fileHandlePrototypeFsync,
+      writev: fileHandlePrototypeWritev,
+    } = FileHandle.prototype);
+  }
+  return FileHandle;
+}
 type FileHandle = import("node:fs/promises").FileHandle & {
   on(event: any, listener: any): FileHandle;
 };
@@ -33,22 +42,13 @@ type FSStream = import("node:fs").ReadStream &
   };
 type FD = number;
 
-const { validateInteger, validateInt32, validateFunction } = require("internal/validators");
-
 const kIsPerformingIO = Symbol("kIsPerformingIO");
 const kIoDone = Symbol("kIoDone");
 // Bun supports a fast path for `createWriteStream("path.txt")` where instead of
 // using `node:fs`, `Bun.file(...).writer()` is used instead.
 const kWriteStreamFastPath = Symbol("kWriteStreamFastPath");
 const kFs = Symbol("kFs");
 
-const {
-  read: fileHandlePrototypeRead,
-  write: fileHandlePrototypeWrite,
-  fsync: fileHandlePrototypeFsync,
-  writev: fileHandlePrototypeWritev,
-} = FileHandle.prototype;
-
 const fileHandleStreamFs = (fh: FileHandle) => ({
   // try to use the basic fs.read/write/fsync if available, since they are less
   // abstractions. however, node.js allows patching the file handle, so this has
@@ -132,6 +132,7 @@ function ReadStream(this: FSStream, path, options): void {
     return new ReadStream(path, options);
   }
 
+  const { validateInteger, validateInt32, validateFunction } = require("internal/validators");
   options = copyObject(getStreamOptions(options));
 
   // Only buffers are supported.
@@ -161,7 +162,7 @@ function ReadStream(this: FSStream, path, options): void {
     }
     this.fd = fd;
     this[kFs] = customFs || fs;
-  } else if (typeof fd === "object" && fd instanceof FileHandle) {
+  } else if (typeof fd === "object" && fd instanceof loadFileHandle()) {
     if (options.fs) {
       throw $ERR_METHOD_NOT_IMPLEMENTED("fs.FileHandle with custom fs operations");
     }
@@ -393,6 +394,7 @@ function WriteStream(this: FSStream, path: string | null, options?: any): void {
   }
 
   let fastPath = options?.$fastPath;
+  const { validateInteger, validateInt32, validateFunction } = require("internal/validators");
 
   options = copyObject(getStreamOptions(options));
 
@@ -422,7 +424,7 @@ function WriteStream(this: FSStream, path: string | null, options?: any): void {
     }
     this.fd = fd;
     this[kFs] = customFs || fs;
-  } else if (typeof fd === "object" && fd instanceof FileHandle) {
+  } else if (typeof fd === "object" && fd instanceof loadFileHandle()) {
     if (options.fs) {
       throw $ERR_METHOD_NOT_IMPLEMENTED("fs.FileHandle with custom fs operations");
     }

src/js/internal/http/FakeSocket.ts

@@ -1,6 +1,5 @@
 const { kInternalSocketData, serverSymbol } = require("internal/http");
-const { kAutoDestroyed } = require("internal/shared");
-const { Duplex } = require("internal/stream");
+const Duplex = require("internal/streams/duplex");
 
 type FakeSocket = InstanceType<typeof FakeSocket>;
 var FakeSocket = class Socket extends Duplex {
@@ -38,7 +37,7 @@ var FakeSocket = class Socket extends Duplex {
   _destroy(_err, _callback) {
     const socketData = this[kInternalSocketData];
     if (!socketData) return; // sometimes 'this' is Socket not FakeSocket
-    if (!socketData[1]["req"][kAutoDestroyed]) socketData[1].end();
+    if (!socketData[1]["req"][require("internal/shared").kAutoDestroyed]) socketData[1].end();
   }
 
   _final(_callback) {}

src/js/internal/primordials.js

@@ -36,6 +36,17 @@ function uncurryThis(func) {
   return FunctionPrototypeCall.bind(func);
 }
 
+const ArrayPrototypeForEach = uncurryThis(Array.prototype.forEach);
+const ArrayPrototypeMap = uncurryThis(Array.prototype.map);
+const ArrayPrototypeSymbolIterator = uncurryThis(Array.prototype[Symbol.iterator]);
+const ArrayIteratorPrototypeNext = uncurryThis(Array.prototype[Symbol.iterator]().next);
+const StringPrototypeSymbolIterator = uncurryThis(String.prototype[Symbol.iterator]);
+const StringIteratorPrototypeNext = uncurryThis(
+  Reflect.getPrototypeOf(String.prototype[Symbol.iterator].$call("")).next,
+);
+const PromiseAll = Promise.all;
+const PromiseResolve = Promise.$resolve.bind(Promise);
+
 const copyProps = (src, dest) => {
   ArrayPrototypeForEach(Reflect.ownKeys(src), key => {
     if (!Reflect.getOwnPropertyDescriptor(dest, key)) {
@@ -77,26 +88,23 @@ const makeSafe = (unsafe, safe) => {
   return safe;
 };
 
-const StringIterator = uncurryThis(String.prototype[Symbol.iterator]);
-const StringIteratorPrototype = Reflect.getPrototypeOf(StringIterator(""));
-const ArrayPrototypeForEach = uncurryThis(Array.prototype.forEach);
-const ArrayPrototypeSymbolIterator = uncurryThis(Array.prototype[Symbol.iterator]);
-const ArrayIteratorPrototypeNext = uncurryThis(Array.prototype[Symbol.iterator]().next);
-const SafeArrayIterator = createSafeIterator(ArrayPrototypeSymbolIterator, ArrayIteratorPrototypeNext);
+let SafeArrayIterator;
+function getSafeArrayIterator() {
+  return (SafeArrayIterator ??= createSafeIterator(ArrayPrototypeSymbolIterator, ArrayIteratorPrototypeNext));
+}
 
-const ArrayPrototypeMap = Array.prototype.map;
 const PromisePrototypeThen = $Promise.prototype.$then;
 
-const arrayToSafePromiseIterable = (promises, mapFn) =>
-  new SafeArrayIterator(
-    ArrayPrototypeMap.$call(
+const arrayToSafePromiseIterable = (promises, mapFn) => {
+  const SafeArrayIterator = getSafeArrayIterator();
+  return new SafeArrayIterator(
+    ArrayPrototypeMap(
       promises,
       (promise, i) =>
         new Promise((a, b) => PromisePrototypeThen.$call(mapFn == null ? promise : mapFn(promise, i), a, b)),
     ),
   );
-const PromiseAll = Promise.all;
-const PromiseResolve = Promise.$resolve.bind(Promise);
+};
 const SafePromiseAll = (promises, mapFn) => PromiseAll(arrayToSafePromiseIterable(promises, mapFn));
 // Shared scheduler for SafePromiseAllReturnVoid/ReturnArrayLike: `returnVal`
 // is null for the void variant (no result bookkeeping, resolves with nothing).
@@ -126,64 +134,87 @@ const SafePromiseAllReturnArrayLike = (promises, mapFn) => {
   return safePromiseAllCollect(promises, mapFn, returnVal);
 };
 
-export default {
+const primordials = {
   Array,
-  SafeArrayIterator,
-  MapPrototypeGetSize: getGetter(Map, "size"),
   Number,
   Object,
   RegExp,
-  SafeStringIterator: createSafeIterator(StringIterator, uncurryThis(StringIteratorPrototype.next)),
-  SafeMap: makeSafe(
+  SafePromiseAll,
+  SafePromiseAllReturnArrayLike,
+  SafePromiseAllReturnVoid,
+  String,
+  Uint8ClampedArray,
+  Uint8Array,
+  Uint16Array,
+  Uint32Array,
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  Float16Array,
+  Float32Array,
+  Float64Array,
+  BigUint64Array,
+  BigInt64Array,
+  uncurryThis,
+};
+
+function defineLazy(name, initialize) {
+  Object.defineProperty(primordials, name, {
+    get() {
+      const value = initialize();
+      Reflect.defineProperty(primordials, name, { value, writable: true, enumerable: true, configurable: true });
+      return value;
+    },
+    enumerable: true,
+    configurable: true,
+  });
+}
+
+defineLazy("SafeArrayIterator", getSafeArrayIterator);
+defineLazy("MapPrototypeGetSize", () => getGetter(Map, "size"));
+defineLazy("SetPrototypeGetSize", () => getGetter(Set, "size"));
+defineLazy("TypedArrayPrototypeGetLength", () => getGetter(Uint8Array, "length"));
+defineLazy("TypedArrayPrototypeGetSymbolToStringTag", () => getGetter(Uint8Array, Symbol.toStringTag));
+defineLazy("SafeStringIterator", () => createSafeIterator(StringPrototypeSymbolIterator, StringIteratorPrototypeNext));
+defineLazy("SafeMap", () =>
+  makeSafe(
     Map,
     class SafeMap extends Map {
       constructor(i) {
         super(i);
       }
     },
   ),
-  SafePromiseAll,
-  SafePromiseAllReturnArrayLike,
-  SafePromiseAllReturnVoid,
-  SafeSet: makeSafe(
+);
+defineLazy("SafeSet", () =>
+  makeSafe(
     Set,
     class SafeSet extends Set {
       constructor(i) {
         super(i);
       }
     },
   ),
-  SafeWeakSet: makeSafe(
+);
+defineLazy("SafeWeakSet", () =>
+  makeSafe(
     WeakSet,
     class SafeWeakSet extends WeakSet {
       constructor(i) {
         super(i);
       }
     },
   ),
-  SafeWeakMap: makeSafe(
+);
+defineLazy("SafeWeakMap", () =>
+  makeSafe(
     WeakMap,
     class SafeWeakMap extends WeakMap {
       constructor(i) {
         super(i);
       }
     },
   ),
-  SetPrototypeGetSize: getGetter(Set, "size"),
-  String,
-  TypedArrayPrototypeGetLength: getGetter(Uint8Array, "length"),
-  TypedArrayPrototypeGetSymbolToStringTag: getGetter(Uint8Array, Symbol.toStringTag),
-  Uint8ClampedArray,
-  Uint8Array,
-  Uint16Array,
-  Uint32Array,
-  Int8Array,
-  Int16Array,
-  Int32Array,
-  Float16Array,
-  Float32Array,
-  Float64Array,
-  BigUint64Array,
-  BigInt64Array,
-  uncurryThis,
-};
+);
+
+export default primordials;