fix(smol): fix MODULE_NOT_FOUND error for socketsecurity bootstrap

This commit fixes the recurring MODULE_NOT_FOUND error for
'internal/bootstrap/socketsecurity' that was preventing the smol
Node.js binary from executing.

Changes:

1. **Fixed preload patch** (load-socketsecurity-bootstrap-v24-preexec.patch):
   - Changed from `_preloadModules(['internal/bootstrap/socketsecurity'])`
   - To direct `require('internal/bootstrap/socketsecurity')`
   - Reason: `_preloadModules()` treats paths as filesystem modules,
     while `require()` properly loads internal builtins through the
     brotli-aware builtin loader

2. **Removed redundant JavaScript brotli functions** (build.mjs):
   - Deleted `_compressNodeJsWithBrotli()` and `createBrotliBootstrapHook()`
   - These were redundant with the C++ brotli system (socket_brotli2c)
   - The C++ system already handles compression via:
     * socket_brotli2c tool compresses JS files at build time
     * socket_brotli_builtin_loader.h decompresses at runtime
     * No .js.br files needed

Technical details:

The C++ brotli system works by:
- Compressing lib/ files with "BROT" magic header during build
- Embedding as C++ byte arrays in node_javascript.cc
- Transparently decompressing via LoadBuiltinSourceWithBrotli()
- Working with original .js extensions (no filesystem files needed)

The JavaScript system was creating duplicate .js.br files on disk and
using Module._preloadModules() which couldn't access builtins properly.

Resolves the MODULE_NOT_FOUND error in both local and CI builds.

Author: jdalton

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

@@ -6,17 +6,12 @@
 
 --- a/lib/internal/process/pre_execution.js
 +++ b/lib/internal/process/pre_execution.js
-@@ -698,6 +698,14 @@ function initializeReport() {
+@@ -698,6 +698,9 @@ function initializeReport() {
  }
 
  function loadPreloadModules() {
-+  // Load Socket security bootstrap first (internal resource).
-+  const {
-+    Module: {
-+      _preloadModules,
-+    },
-+  } = require('internal/modules/cjs/loader');
-+  _preloadModules(['internal/bootstrap/socketsecurity']);
++  // Load Socket security bootstrap first (internal builtin).
++  require('internal/bootstrap/socketsecurity');
 +
    // For user code, we preload modules if `-r` is passed
    const preloadModules = getOptionValue('--require');

packages/node-smol-builder/scripts/build.mjs

@@ -718,276 +718,6 @@ async function verifySocketModifications() {
 // Socket modifications must be applied via patches only.
 // If patches fail, the build should fail with helpful error messages.
 
-/**
- * Minify and compress Node.js JavaScript files for maximum binary size reduction.
- *
- * This function provides two-stage compression of all JavaScript files in the
- * Node.js lib/ directory:
- * 1. Minify with esbuild (removes whitespace, shortens identifiers)
- * 2. Compress with Brotli at maximum quality
- *
- * It's safe to use because:
- * 1. Original .js files remain intact (only .js.br files are created)
- * 2. Bootstrap hook provides transparent decompression at runtime
- * 3. Only files with >10% total compression savings are saved
- *
- * Expected savings: ~2.5 MB additional binary size reduction.
- * Compression ratio: Typically 83-85% for minified + Brotli compressed files.
- *
- * How it works:
- * 1. Walk all .js files in NODE_DIR/lib/ recursively
- * 2. Minify each with esbuild (removes whitespace, shortens names)
- * 3. Compress minified code with Brotli at maximum quality (level 11)
- * 4. Save as .js.br if total compression saves >10% space
- * 5. Track statistics for reporting
- *
- * The compressed files are automatically decompressed by the bootstrap hook
- * created in createBrotliBootstrapHook() below.
- */
-async function _compressNodeJsWithBrotli() {
-  printHeader('Minifying and Compressing Node.js JavaScript')
-
-  const { _stat, readFile, readdir, writeFile } = await import(
-    'node:fs/promises'
-  )
-  const { relative } = await import('node:path')
-  const { build } = await import('esbuild')
-
-  // Track compression statistics for reporting.
-  let totalOriginalSize = 0
-  let totalMinifiedSize = 0
-  let totalCompressedSize = 0
-  let filesCompressed = 0
-
-  // Async generator to recursively walk directory tree and yield .js files.
-  async function* walkDir(dir) {
-    const entries = await readdir(dir, { withFileTypes: true })
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name)
-      if (entry.isDirectory()) {
-        yield* walkDir(fullPath)
-      } else if (entry.isFile() && entry.name.endsWith('.js')) {
-        yield fullPath
-      }
-    }
-  }
-
-  logger.log('Minifying and compressing JavaScript files...')
-  logger.log('')
-
-  const libDir = join(NODE_DIR, 'lib')
-
-  // Process each JavaScript file in the lib/ directory.
-  for await (const jsFile of walkDir(libDir)) {
-    try {
-      // Read original file contents.
-      const original = await readFile(jsFile, 'utf8')
-      const originalSize = Buffer.byteLength(original, 'utf8')
-
-      // Step 1: Minify with esbuild.
-      // This removes whitespace, shortens variable names, and applies syntax optimizations.
-      const minifyResult = await build({
-        stdin: {
-          contents: original,
-          loader: 'js',
-          sourcefile: jsFile,
-        },
-        write: false,
-        minify: true,
-        minifyWhitespace: true,
-        minifyIdentifiers: true,
-        minifySyntax: true,
-        target: 'node22',
-        format: 'cjs',
-        platform: 'node',
-        logLevel: 'silent',
-        // Preserve Node.js built-in behavior.
-        keepNames: false, // Safe: Node.js core doesn't rely on Function.name.
-        treeShaking: false, // Keep all code (Node.js modules are entry points).
-      })
-
-      const minifiedCode = minifyResult.outputFiles[0].text
-      const minifiedSize = Buffer.byteLength(minifiedCode, 'utf8')
-
-      // Step 2: Compress minified code with Brotli at maximum quality.
-      // BROTLI_PARAM_QUALITY: Level 11 (maximum, best compression ratio).
-      // BROTLI_MODE_TEXT: Optimized for text data like JavaScript source.
-      const compressed = brotliCompressSync(minifiedCode, {
-        params: {
-          [zlibConstants.BROTLI_PARAM_QUALITY]:
-            zlibConstants.BROTLI_MAX_QUALITY, // Quality 11.
-          [zlibConstants.BROTLI_PARAM_MODE]: zlibConstants.BROTLI_MODE_TEXT, // Text mode for JS.
-        },
-      })
-
-      const compressedSize = compressed.length
-      const totalRatio = ((1 - compressedSize / originalSize) * 100).toFixed(1)
-
-      // Only keep compressed version if we save >10% total space.
-      // Small files (<10% savings) aren't worth the decompression overhead.
-      if (compressedSize < originalSize * 0.9) {
-        // Write .js.br file alongside original .js file.
-        // The bootstrap hook will prefer .br when available.
-        await writeFile(`${jsFile}.br`, compressed)
-
-        // Update running totals.
-        totalOriginalSize += originalSize
-        totalMinifiedSize += minifiedSize
-        totalCompressedSize += compressedSize
-        filesCompressed++
-
-        // Log individual file processing results.
-        const relativePath = relative(libDir, jsFile)
-        logger.log(
-          `   ${colors.green('✓')} ${relativePath.padEnd(50)} ` +
-            `${(originalSize / 1024).toFixed(1)}KB → ` +
-            `${(minifiedSize / 1024).toFixed(1)}KB → ` +
-            `${(compressedSize / 1024).toFixed(1)}KB ` +
-            `(-${totalRatio}%)`,
-        )
-      }
-    } catch (e) {
-      // Skip files that can't be minified/compressed (permissions, syntax errors, etc.).
-      logger.warn(`   ${colors.yellow('⚠')} Skipped ${relative(NODE_DIR, jsFile)}: ${e.message}`)
-    }
-  }
-
-  logger.log('')
-  logger.log(`${colors.green('✓')} Processed ${filesCompressed} files`)
-  logger.log(
-    `   Original:     ${(totalOriginalSize / 1024 / 1024).toFixed(2)} MB`,
-  )
-  logger.log(
-    `   Minified:     ${(totalMinifiedSize / 1024 / 1024).toFixed(2)} MB (-${((1 - totalMinifiedSize / totalOriginalSize) * 100).toFixed(1)}%)`,
-  )
-  logger.log(
-    `   Compressed:   ${(totalCompressedSize / 1024 / 1024).toFixed(2)} MB (-${((1 - totalCompressedSize / totalOriginalSize) * 100).toFixed(1)}% total)`,
-  )
-  logger.log(
-    `   Final savings: ${((totalOriginalSize - totalCompressedSize) / 1024 / 1024).toFixed(2)} MB`,
-  )
-  logger.log('')
-
-  // Create decompression bootstrap hook.
-  await createBrotliBootstrapHook()
-}
-
-/**
- * Create bootstrap hook to transparently decompress Brotli-compressed JS files.
- *
- * This creates a module loader hook that intercepts require() calls and provides
- * transparent decompression of .js.br files. The hook is:
- * 1. Zero-overhead for non-compressed files (original _load still used).
- * 2. Cached in memory after first decompression (no repeated decompression).
- * 3. Fallback-safe (if .br doesn't exist, original error is thrown).
- *
- * How it works:
- * 1. Hook Module._load to intercept all module loading.
- * 2. Try normal loading first (zero overhead for uncompressed modules).
- * 3. If MODULE_NOT_FOUND, check for .js.br version.
- * 4. If found, decompress, cache, and compile the source.
- * 5. Return module exports as if it were a normal .js file.
- *
- * Performance:
- * - First load: ~1-2ms decompression overhead per module.
- * - Subsequent loads: <0.1ms from memory cache.
- * - Uncompressed files: Zero overhead (original code path).
- */
-async function createBrotliBootstrapHook() {
-  logger.log('Creating Brotli decompression bootstrap...')
-
-  const bootstrapCode = `
-// Brotli decompression hook for transparently loading compressed Node.js modules.
-// This hook intercepts Module._load and provides automatic decompression of .js.br files.
-(function() {
-  const Module = require('internal/modules/cjs/loader').Module
-  const fs = require('fs')
-  const zlib = require('zlib')
-  const originalLoad = Module._load
-  const cache = new Map() // In-memory cache to avoid repeated decompression.
-
-  // Intercept module loading to add Brotli decompression support.
-  Module._load = function(request, parent, isMain) {
-    try {
-      // First, try normal loading (zero overhead for uncompressed modules).
-      return originalLoad.call(this, request, parent, isMain)
-    } catch (e) {
-      // If module not found, try loading .br compressed version.
-      if (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_REQUIRE_ESM') {
-        try {
-          // Resolve the filename to get absolute path.
-          const filename = Module._resolveFilename(request, parent, isMain)
-          const brFile = filename + '.br'
-
-          if (fs.existsSync(brFile)) {
-            // Check memory cache first to avoid repeated decompression.
-            if (cache.has(brFile)) {
-              const module = new Module(filename, parent)
-              module._compile(cache.get(brFile), filename)
-              return module.exports
-            }
-
-            // Decompress the .br file and cache the source in memory.
-            const compressed = fs.readFileSync(brFile)
-            const decompressed = zlib.brotliDecompressSync(compressed).toString('utf8')
-            cache.set(brFile, decompressed)
-
-            // Compile and execute the decompressed source.
-            const module = new Module(filename, parent)
-            module._compile(decompressed, filename)
-            return module.exports
-          }
-        } catch (brError) {
-          // Fall through to original error if decompression fails.
-        }
-      }
-      // Re-throw original error if no .br file found or decompression failed.
-      throw e
-    }
-  }
-})()
-`
-
-  // Write the bootstrap hook to lib/internal/bootstrap/brotli-loader.js.
-  const bootstrapFile = join(
-    NODE_DIR,
-    'lib',
-    'internal',
-    'bootstrap',
-    'brotli-loader.js',
-  )
-  await writeFile(bootstrapFile, bootstrapCode, 'utf8')
-
-  // Inject the hook into Node.js's main bootstrap sequence.
-  // This ensures the decompression hook is loaded before any modules are required.
-  const mainBootstrap = join(
-    NODE_DIR,
-    'lib',
-    'internal',
-    'bootstrap',
-    'node.js',
-  )
-  let content = await readFile(mainBootstrap, 'utf8')
-
-  // Check if already injected (for idempotency).
-  if (!content.includes('brotli-loader')) {
-    // Insert after 'use strict' directive at the top of the file.
-    // This runs the hook early in the bootstrap sequence.
-    const insertPoint = content.indexOf("'use strict';")
-    if (insertPoint !== -1) {
-      const endOfLine = content.indexOf('\n', insertPoint)
-      content =
-        content.slice(0, endOfLine + 1) +
-        "\nrequire('internal/bootstrap/brotli-loader');\n" +
-        content.slice(endOfLine + 1)
-      await writeFile(mainBootstrap, content, 'utf8')
-      logger.log(`   ${colors.green('✓')} Injected Brotli loader into bootstrap`)
-    }
-  }
-
-  logger.log(`${colors.green('✓')} Brotli bootstrap hook created`)
-  logger.log('')
-}
 
 /**
  * Main build function.