perf(smol): use vm.compileFunction() and remove internal path remapping

Upgraded bootstrap loading to use modern C++ API:
- vm.compileFunction() directly compiles with module parameters (single C++ call)
- Removed Module.wrap() + vm.runInThisContext() (two-step process)
- Better performance and cleaner code

Removed internal path remapping:
- No longer needed with vm.compileFunction() approach
- Bootstrap now runs in proper module context with standard require()
- Deleted ~90 lines of mapping code from esbuild plugin
- Simplified plugin to only handle Unicode property transformations

Benefits:
- Faster bootstrap execution (direct C++ compilation)
- Standard Node.js module resolution (no path hacks)
- Easier maintenance (less custom code)

Author: jdalton

packages/bootstrap/.config/esbuild-plugin-smol-transform.mjs

@@ -1,90 +1,13 @@
 /**
- * esbuild plugin to transform node:* requires to internal/* requires.
- * Also transforms Unicode property escapes to explicit character ranges.
+ * esbuild plugin to transform Unicode property escapes to explicit character ranges.
  *
- * This makes the bootstrap compatible with Node.js internal bootstrap context
- * for smol builds (built with --with-intl=none, no ICU support).
+ * This makes the bootstrap compatible with Node.js smol builds
+ * (built with --with-intl=none, no ICU support).
  */
 
 import { parse } from '@babel/parser'
 import MagicString from 'magic-string'
 
-// Prefix-only modules that have no unprefixed form.
-// These ONLY support node:* syntax.
-const prefixOnlyModules = new Set([
-  'node:sea',
-  'node:sqlite',
-  'node:test',
-  'node:test/reporters',
-])
-
-// Map core module requires to their internal bootstrap equivalents.
-// Based on Module.builtinModules from Node.js v24.10.0.
-// Format: [moduleName, bootstrapPath]
-// Handles both 'node:x' and plain 'x' variants (except prefix-only modules).
-const requireMappings = new Map([
-  // Core modules with internal equivalents.
-  ['child_process', 'internal/child_process'],
-  ['fs', 'fs'],
-  ['fs/promises', 'internal/fs/promises'],
-
-  // Stream internals.
-  ['stream', 'stream'],
-  ['stream/promises', 'stream/promises'],
-  ['stream/web', 'internal/webstreams/readablestream'],
-
-  // Path variants.
-  ['path', 'path'],
-  ['path/posix', 'path'],
-  ['path/win32', 'path'],
-
-  // Core modules available at top level.
-  ['assert', 'assert'],
-  ['assert/strict', 'assert/strict'],
-  ['async_hooks', 'async_hooks'],
-  ['buffer', 'buffer'],
-  ['cluster', 'cluster'],
-  ['console', 'console'],
-  ['constants', 'constants'],
-  ['crypto', 'crypto'],
-  ['dgram', 'dgram'],
-  ['diagnostics_channel', 'diagnostics_channel'],
-  ['dns', 'dns'],
-  ['dns/promises', 'dns/promises'],
-  ['domain', 'domain'],
-  ['events', 'events'],
-  ['http', 'http'],
-  ['http2', 'http2'],
-  ['https', 'https'],
-  ['inspector', 'inspector'],
-  ['inspector/promises', 'inspector/promises'],
-  ['module', 'module'],
-  ['net', 'net'],
-  ['os', 'os'],
-  ['perf_hooks', 'perf_hooks'],
-  ['process', 'process'],
-  ['punycode', 'punycode'],
-  ['querystring', 'querystring'],
-  ['readline', 'readline'],
-  ['readline/promises', 'readline/promises'],
-  ['repl', 'repl'],
-  ['string_decoder', 'string_decoder'],
-  ['sys', 'sys'],
-  ['timers', 'timers'],
-  ['timers/promises', 'timers/promises'],
-  ['tls', 'tls'],
-  ['trace_events', 'trace_events'],
-  ['tty', 'tty'],
-  ['url', 'url'],
-  ['util', 'util'],
-  ['util/types', 'internal/util/types'],
-  ['v8', 'v8'],
-  ['vm', 'vm'],
-  ['wasi', 'wasi'],
-  ['worker_threads', 'worker_threads'],
-  ['zlib', 'zlib'],
-])
-
 /**
  * Map of Unicode property escapes to explicit character ranges.
  * These are used when Node.js is built without ICU support (--with-intl=none).
@@ -340,23 +263,6 @@ export function smolTransformPlugin() {
           // This is necessary for Node.js built without ICU (--with-intl=none).
           content = replaceUnicodeProperties(content)
 
-          // Replace require("node:X") and require("X") with correct bootstrap path.
-          for (const [moduleName, bootstrapPath] of requireMappings) {
-            // Handle node:x variant.
-            content = content.replace(
-              new RegExp(`require\\(["']node:${moduleName}["']\\)`, 'g'),
-              `require("${bootstrapPath}")`,
-            )
-            // Handle plain x variant (if different from bootstrap path).
-            // Skip if this is a prefix-only module.
-            if (moduleName !== bootstrapPath && !prefixOnlyModules.has(`node:${moduleName}`)) {
-              content = content.replace(
-                new RegExp(`require\\(["']${moduleName}["']\\)`, 'g'),
-                `require("${bootstrapPath}")`,
-              )
-            }
-          }
-
           // Update the output content.
           output.contents = Buffer.from(content, 'utf8')
         }

packages/node-smol-builder/patches/load-socketsecurity-bootstrap-v24-preexec.template.patch

@@ -1,21 +1,21 @@
 # @node-versions: v24.10.0+
-# @description: Load Socket security bootstrap using Module.wrap() + VM (supports async!)
+# @description: Load Socket security bootstrap using vm.compileFunction() C++ API
 #
-# This approach uses the same mechanism as `--require` modules, which properly handles async code:
-# 1. Module.wrap() creates proper module context (exports, require, module, __filename, __dirname)
-# 2. vm.runInThisContext() compiles and executes the wrapped code
+# This approach uses the modern C++ API for optimal performance:
+# 1. vm.compileFunction() directly compiles code with module context parameters
+# 2. Single C++ call (no wrapping + compilation steps)
 # 3. Async code can run in the background while Node.js continues initialization
 #
 # The bootstrap code is embedded as base64 and decoded at runtime (no filesystem dependency).
 
 --- a/lib/internal/process/pre_execution.js
 +++ b/lib/internal/process/pre_execution.js
-@@ -673,6 +673,53 @@ function runEmbedderPreload() {
+@@ -673,6 +673,46 @@ function runEmbedderPreload() {
    internalBinding('mksnapshot').runEmbedderPreload(process, require);
  }
 
  function loadPreloadModules() {
-+  // Load Socket security bootstrap using Module.wrap() + VM approach.
++  // Load Socket security bootstrap using vm.compileFunction() C++ API.
 +  // This allows async code in the bootstrap (unlike direct require()).
 +  (function loadSocketBootstrap() {
 +    // Bootstrap code embedded as base64 (build system replaces this placeholder).
@@ -32,37 +32,24 @@
 +      // Decode bootstrap from base64.
 +      const bootstrapCode = Buffer.from(SOCKET_BOOTSTRAP_B64, 'base64').toString('utf8');
 +
-+      // Create dummy module (same approach as Module._preloadModules).
++      // Create module context.
 +      const bootstrapModule = new Module('socket:bootstrap', null);
 +      bootstrapModule.filename = 'socket:bootstrap';
 +      bootstrapModule.paths = [];
++      const exports = {};
++      bootstrapModule.exports = exports;
 +
-+      // Wrap code with proper module wrapper.
-+      // This adds: (function (exports, require, module, __filename, __dirname) { ... })
-+      const wrapped = Module.wrap(bootstrapCode);
-+
-+      // Compile using VM (this supports async code execution!).
-+      const compiledWrapper = vm.runInThisContext(wrapped, {
++      // Compile using C++ API with module parameters.
++      const compiledFn = vm.compileFunction(bootstrapCode, ['exports', 'require', 'module', '__filename', '__dirname'], {
 +        filename: 'socket:bootstrap',
 +        lineOffset: 0,
-+        displayErrors: true,
++        columnOffset: 0,
 +      });
 +
 +      // Execute with module context.
-+      const exports = {};
-+      bootstrapModule.exports = exports;
-+
-+      // Call the wrapped function with proper context.
 +      // If bootstrap contains async code (main().catch(...)), it starts executing
 +      // but returns immediately - async operations run in background.
-+      compiledWrapper.call(
-+        exports,
-+        exports,
-+        require,
-+        bootstrapModule,
-+        'socket:bootstrap',
-+        ''
-+      );
++      compiledFn.call(exports, exports, require, bootstrapModule, 'socket:bootstrap', '');
 +    } catch (err) {
 +      // Use stderr.write to avoid console dependencies during early bootstrap.
 +      process.stderr.write(`Socket bootstrap error: ${err.message}\n${err.stack}\n`);