seabox 0.1.2 → 0.3.0

package/lib/multi-target-builder.mjs

@@ -1,697 +1,701 @@
-/**
- * multi-target-builder.mjs
- * Orchestrate parallel builds for multiple target platforms.
- */
-
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-import crypto from 'crypto';
-import { fileURLToPath } from 'url';
-import Module from 'module';
-
-import { bundleWithRollup } from './rolldown-bundler.mjs';
-import { BuildCache } from './build-cache.mjs';
-import { parseTarget } from './config.mjs';
-import { generateManifest, serializeManifest } from './manifest.mjs';
-import { createSeaConfig, writeSeaConfigJson, generateBlob } from './blob.mjs';
-import { fetchNodeBinary } from './fetch-node.mjs';
-import { injectBlob } from './inject.mjs';
-import { generateEncryptionKey, encryptAssets, keyToObfuscatedCode } from './crypto-assets.mjs';
-import { obfuscateBootstrap } from './obfuscate.mjs';
-import { bundleEntry } from './entry-bundler.mjs';
-import * as diag from './diagnostics.mjs';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const require = Module.createRequire(import.meta.url);
-
-/**
- * Multi-target build orchestrator
- */
-export class MultiTargetBuilder {
-  /**
-   * @param {import('./config.mjs').SeaboxConfigV2} config - Build configuration
-   * @param {string} projectRoot - Project root directory
-   */
-  constructor(config, projectRoot = process.cwd()) {
-    this.config = config;
-    this.projectRoot = projectRoot;
-    this.cache = new BuildCache(path.join(projectRoot, 'node_modules', '.cache', '.seabox-cache'));
-    this.verbose = config.verbose || false;
-    
-    // Set verbose mode for diagnostics
-    diag.setVerbose(this.verbose);
-  }
-
-  /**
-   * Build all configured targets
-   * @returns {Promise<Array<{target: string, path: string}>>}
-   */
-  async buildAll() {
-    diag.header('Seabox Multi-Target Build');
-
-    // Step 1: Bundle entry once (platform-agnostic JavaScript)
-    const { bundledPath, nativeModules, detectedAssets } = await this.bundleEntry();
-
-    if (this.verbose && detectedAssets.size > 0) {
-      diag.separator();
-      diag.info('Auto-detected assets:');
-      for (const assetPath of detectedAssets) {
-        diag.listItem(assetPath, 1);
-      }
-    }
-
-    if (this.verbose && nativeModules.size > 0) {
-      diag.separator();
-      diag.info('Native modules detected:');
-      for (const [name, info] of nativeModules) {
-        diag.listItem(`${name}: ${info.packageRoot}`, 1);
-      }
-    }
-
-    // Step 2: Build all targets (can be parallelized)
-    diag.separator();
-    diag.info(`Building ${this.config.outputs.length} target(s)...`);
-    diag.separator();
-    
-    const buildPromises = this.config.outputs.map((output, index) =>
-      this.buildTarget(output, bundledPath, nativeModules, detectedAssets, index + 1)
-    );
-
-    const results = await Promise.all(buildPromises);
-
-    diag.summary('All builds completed successfully!');
-    
-    return results;
-  }
-
-  /**
-   * Bundle the entry file with Rollup
-   * @returns {Promise<{bundledPath: string, nativeModules: Map}>}
-   */
-  async bundleEntry() {
-    diag.step(1, 6, 'Bundling application with Rollup...');
-    
-    const entryPath = path.resolve(this.projectRoot, this.config.entry);
-    
-    if (!fs.existsSync(entryPath)) {
-      throw new Error(`Entry file not found: ${entryPath}`);
-    }
-
-    const bundledPath = path.join(this.projectRoot, 'out', '_sea-entry.js');
-    
-    // Create output directory
-    fs.mkdirSync(path.dirname(bundledPath), { recursive: true });
-
-    const result = await bundleWithRollup(
-      entryPath, 
-      bundledPath, 
-      { ...this.config, _projectRoot: this.projectRoot }, 
-      process.platform,  // Use current platform for bundling (JavaScript is platform-agnostic)
-      process.arch,
-      this.verbose
-    );
-    
-    diag.success(`Bundle created: ${bundledPath}`);
-    
-    return result;
-  }
-
-
-
-  /**
-   * Build a single target
-   * @param {import('./config.mjs').OutputTarget} outputConfig - Target configuration
-   * @param {string} bundledEntryPath - Path to bundled entry
-   * @param {Map} nativeModules - Detected native modules
-   * @param {Set<string>} detectedAssets - Auto-detected assets from bundler
-   * @param {number} buildNumber - Build number for display
-   * @returns {Promise<{target: string, path: string}>}
-   */
-  async buildTarget(outputConfig, bundledEntryPath, nativeModules, detectedAssets, buildNumber) {
-    const { target, path: outputPath, output: executableName } = outputConfig;
-    const { nodeVersion, platform, arch } = parseTarget(target);
-
-    diag.subheader(`[Build ${buildNumber}] Target: ${target}`);
-
-    // Step 1: Rebuild native modules for this target
-    const rebuiltModules = await this.rebuildNativeModulesForTarget(
-      nativeModules,
-      target,
-      buildNumber
-    );
-
-    // Step 2: Collect config assets (manual globs)
-    const configAssets = await this.collectConfigAssets(
-      this.config.assets || [],
-      buildNumber
-    );
-
-    // Step 3: Collect auto-detected assets (from path.join(__dirname, ...))
-    const autoAssets = await this.collectDetectedAssets(
-      detectedAssets,
-      buildNumber
-    );
-
-    // Step 4: Collect platform-specific libraries (DLLs/SOs)
-    const platformLibraries = await this.collectPlatformLibraries(
-      outputConfig.libraries,
-      platform,
-      arch,
-      buildNumber
-    );
-
-    // Step 5: Prepare bundled entry with bootstrap
-    const finalEntryPath = await this.prepareFinalEntry(
-      bundledEntryPath,
-      buildNumber
-    );
-
-    // Step 6: Combine all assets (dedupe by assetKey)
-    const assetMap = new Map();
-    
-    // Add in order of priority (later overwrites earlier)
-    for (const asset of [...rebuiltModules, ...configAssets, ...autoAssets, ...platformLibraries]) {
-      assetMap.set(asset.assetKey, asset);
-    }
-    
-    const allAssets = Array.from(assetMap.values());
-
-    // Verbose logging: List all embedded assets
-    if (this.verbose) {
-      diag.separator();
-      diag.verbose(`Embedded Assets (${allAssets.length} total):`, 1);
-      
-      const nativeAssets = allAssets.filter(a => a.assetKey.includes('.node'));
-      const libraryAssets = allAssets.filter(a => a.isBinary && !a.assetKey.includes('.node'));
-      const regularAssets = allAssets.filter(a => !a.isBinary);
-      
-      if (nativeAssets.length > 0) {
-        diag.verbose(`Native Modules (${nativeAssets.length}):`, 1);
-        for (const asset of nativeAssets) {
-          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
-          const displayName = path.basename(asset.assetKey);
-          diag.verbose(`- ${displayName} (${size})`, 2);
-        }
-      }
-      
-      if (libraryAssets.length > 0) {
-        diag.verbose(`Platform Libraries (${libraryAssets.length}):`, 1);
-        for (const asset of libraryAssets) {
-          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
-          diag.verbose(`- ${asset.assetKey} (${size})`, 2);
-        }
-      }
-      
-      if (regularAssets.length > 0) {
-        diag.verbose(`Regular Assets (${regularAssets.length}):`, 1);
-        for (const asset of regularAssets) {
-          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
-          diag.verbose(`- ${asset.assetKey} (${size})`, 2);
-        }
-      }
-    }
-
-    // Step 7: Generate SEA
-    await this.generateSEAForTarget({
-      assets: allAssets,
-      entryPath: finalEntryPath,
-      target,
-      outputPath,
-      executableName,
-      platform,
-      arch,
-      nodeVersion,
-      rcedit: outputConfig.rcedit,
-      buildNumber
-    });
-
-    const finalPath = path.join(outputPath, executableName);
-    diag.success(`Build complete: ${finalPath}`);
-
-    // Apply custom signing if configured
-    if (this.config.sign) {
-      await this.applyCustomSigning(finalPath, target, platform, arch, nodeVersion, buildNumber);
-    }
-
-    return {
-      target,
-      path: finalPath
-    };
-  }
-
-  /**
-   * Rebuild native modules for specific target
-   */
-  async rebuildNativeModulesForTarget(nativeModules, target, buildNumber) {
-    if (nativeModules.size === 0) {
-      return [];
-    }
-
-    diag.buildStep(buildNumber, 1, `Rebuilding ${nativeModules.size} native module(s)...`);
-
-    const rebuiltAssets = [];
-    const { platform, arch } = parseTarget(target);
-
-    for (const [moduleKey, moduleInfo] of nativeModules) {
-      const moduleName = moduleInfo.moduleName || path.basename(moduleKey, '.node');
-      
-      try {
-        // Skip rebuilding if this is already a prebuild for the target platform
-        if (moduleInfo.isPrebuild) {
-          diag.verbose(`Using prebuild: ${moduleName}`, 2);
-          
-          rebuiltAssets.push({
-            sourcePath: moduleInfo.binaryPath,
-            assetKey: moduleInfo.assetKey,  // Use original assetKey from bundler
-            isBinary: true,
-            hash: await this.computeHash(moduleInfo.binaryPath)
-          });
-          continue;
-        }
-        
-        // Check cache first
-        const cachedBuild = this.cache.getCachedNativeBuild(moduleInfo.packageRoot, target);
-        
-        if (cachedBuild) {
-          diag.verbose(`Using cached build: ${moduleName}`, 2);
-          
-          rebuiltAssets.push({
-            sourcePath: cachedBuild,
-            assetKey: moduleInfo.assetKey,  // Use original assetKey from bundler
-            isBinary: true,
-            hash: await this.computeHash(cachedBuild)
-          });
-          continue;
-        }
-
-        // Rebuild the module
-        diag.verbose(`Rebuilding: ${moduleName}`, 2);
-
-        await this.rebuildNativeModule(moduleInfo.packageRoot, target);
-
-        // Find the built binary
-        const builtPath = await this.findBuiltBinary(moduleInfo, target);
-        
-        if (builtPath) {
-          // Cache the build
-          this.cache.cacheNativeBuild(moduleInfo.packageRoot, target, builtPath);
-          
-          rebuiltAssets.push({
-            sourcePath: builtPath,
-            assetKey: moduleInfo.assetKey,  // Use original assetKey from bundler
-            isBinary: true,
-            hash: await this.computeHash(builtPath)
-          });
-          
-          diag.verbose(`Built: ${moduleName} -> ${builtPath}`, 2);
-        }
-      } catch (err) {
-        diag.warn(`Failed to rebuild ${moduleName}: ${err.message}`, 2);
-      }
-    }
-
-    diag.success('Native modules processed');
-    return rebuiltAssets;
-  }
-
-  /**
-   * Rebuild a single native module
-   */
-  async rebuildNativeModule(packageRoot, target) {
-    const rebuildScript = path.join(__dirname, '..', 'bin', 'seabox-rebuild.mjs');
-    
-    if (!fs.existsSync(rebuildScript)) {
-      throw new Error('seabox-rebuild.mjs not found');
-    }
-
-    try {
-      execSync(`node "${rebuildScript}" --target ${target} "${packageRoot}"`, {
-        stdio: this.verbose ? 'inherit' : 'pipe',
-        cwd: this.projectRoot
-      });
-    } catch (err) {
-      throw new Error(`Rebuild failed: ${err.message}`);
-    }
-  }
-
-  /**
-   * Find the built .node binary
-   */
-  async findBuiltBinary(moduleInfo, target) {
-    // Try common build locations
-    const searchPaths = [
-      path.join(moduleInfo.packageRoot, 'build/Release'),
-      path.join(moduleInfo.packageRoot, 'build/Debug'),
-      moduleInfo.buildPath
-    ];
-
-    for (const searchPath of searchPaths) {
-      if (fs.existsSync(searchPath)) {
-        const files = fs.readdirSync(searchPath);
-        const nodeFile = files.find(f => f.endsWith('.node'));
-        
-        if (nodeFile) {
-          return path.join(searchPath, nodeFile);
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Collect platform-specific libraries (DLLs, SOs, DYLIBs) that need filesystem extraction
-   * Only includes libraries explicitly listed in config patterns - no automatic discovery.
-   * Libraries referenced in code (e.g., path.join(__dirname, './lib/foo.dll')) are 
-   * already captured by the bundler's asset detection.
-   * 
-   * @param {string[]} libraryPatterns - Explicit glob patterns for libraries from config
-   * @param {string} platform - Target platform
-   * @param {string} arch - Target architecture
-   * @param {number} buildNumber - Build number for display
-   */
-  async collectPlatformLibraries(libraryPatterns, platform, arch, buildNumber) {
-    // Only process explicitly configured library patterns
-    // Do NOT use default patterns - this prevents automatic inclusion of unrelated DLLs
-    if (!libraryPatterns || libraryPatterns.length === 0) {
-      return [];
-    }
-
-    diag.buildStep(buildNumber, 4, `Collecting platform libraries (${platform})...`);
-
-    const { glob } = await import('glob');
-    const libraries = [];
-
-    for (const pattern of libraryPatterns) {
-      const matches = await glob(pattern, {
-        cwd: this.projectRoot,
-        nodir: true,
-        absolute: false,
-        ignore: [
-          '**/node_modules/**',
-          '**/.git/**',
-          '**/dist/**',
-          '**/build/**',
-          '**/out/**',
-          '**/bin/**',
-          '**/obj/**',
-          '**/tools/**',
-          '**/.seabox-cache/**'
-        ]
-      });
-
-      for (const match of matches) {
-        const sourcePath = path.resolve(this.projectRoot, match);
-        
-        libraries.push({
-          sourcePath,
-          assetKey: match.replace(/\\/g, '/'),
-          isBinary: true,
-          hash: await this.computeHash(sourcePath)
-        });
-      }
-    }
-
-    if (libraries.length > 0) {
-      diag.success(`Collected ${libraries.length} library file(s)`);
-    }
-
-    return libraries;
-  }
-
-  /**
-   * Collect assets from config globs
-   * @param {string[]} assetPatterns - Glob patterns for assets
-   * @param {number} buildNumber - Build number for display
-   */
-  async collectConfigAssets(assetPatterns, buildNumber) {
-    if (!assetPatterns || assetPatterns.length === 0) {
-      return [];
-    }
-
-    diag.buildStep(buildNumber, 2, 'Collecting config assets...');
-
-    const { glob } = await import('glob');
-    const assets = [];
-
-    for (const pattern of assetPatterns) {
-      const matches = await glob(pattern, {
-        cwd: this.projectRoot,
-        nodir: true,
-        absolute: false,
-        ignore: [
-          '**/node_modules/**',
-          '**/.git/**',
-          '**/dist/**',
-          '**/build/**',
-          '**/out/**',
-          '**/bin/**',
-          '**/obj/**',
-          '**/tools/**',
-          '**/.seabox-cache/**'
-        ]
-      });
-
-      for (const match of matches) {
-        const sourcePath = path.resolve(this.projectRoot, match);
-        
-        assets.push({
-          sourcePath,
-          assetKey: match.replace(/\\/g, '/'),
-          isBinary: this.isBinaryFile(sourcePath),
-          hash: await this.computeHash(sourcePath)
-        });
-      }
-    }
-
-    if (assets.length > 0) {
-      diag.success(`Collected ${assets.length} config asset(s)`);
-    }
-
-    return assets;
-  }
-
-  /**
-   * Collect auto-detected assets from bundler (path.join(__dirname, ...))
-   * @param {Set<string>} detectedAssets - Asset paths detected during bundling
-   * @param {number} buildNumber - Build number for display
-   */
-  async collectDetectedAssets(detectedAssets, buildNumber) {
-    if (!detectedAssets || detectedAssets.size === 0) {
-      return [];
-    }
-
-    diag.buildStep(buildNumber, 3, 'Processing auto-detected assets...');
-
-    const assets = [];
-
-    for (const assetKey of detectedAssets) {
-      const sourcePath = path.resolve(this.projectRoot, assetKey);
-      
-      // Verify file still exists
-      if (fs.existsSync(sourcePath)) {
-        assets.push({
-          sourcePath,
-          assetKey: assetKey,
-          isBinary: this.isBinaryFile(sourcePath),
-          hash: await this.computeHash(sourcePath)
-        });
-      }
-    }
-
-    if (assets.length > 0) {
-      diag.success(`Collected ${assets.length} auto-detected asset(s)`);
-    }
-
-    return assets;
-  }
-
-  /**
-   * Check if a file is binary based on extension
-   */
-  isBinaryFile(filePath) {
-    const binaryExtensions = ['.node', '.dll', '.so', '.dylib', '.exe', '.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.ttf', '.eot'];
-    const ext = path.extname(filePath).toLowerCase();
-    return binaryExtensions.includes(ext);
-  }
-
-  /**
-   * Prepare final entry with bootstrap
-   */
-  async prepareFinalEntry(bundledEntryPath, buildNumber) {
-    diag.buildStep(buildNumber, 3, 'Preparing bootstrap...');
-
-    const bootstrapPath = path.join(__dirname, 'bootstrap.cjs');
-    const bootstrapContent = fs.readFileSync(bootstrapPath, 'utf8');
-    
-    let augmentedBootstrap = bootstrapContent;
-
-    // Handle encryption if enabled
-    if (this.config.encryptAssets) {
-      const encryptionKey = generateEncryptionKey();
-      const keyCode = keyToObfuscatedCode(encryptionKey);
-      
-      const encryptionSetup = `
-const SEA_ENCRYPTION_KEY = ${keyCode};
-const SEA_ENCRYPTED_ASSETS = new Set([]);
-`;
-      
-      augmentedBootstrap = bootstrapContent.replace(
-        "  'use strict';",
-        "  'use strict';\n" + encryptionSetup
-      );
-      
-      diag.verbose('Encryption enabled and bootstrap obfuscated', 2);
-      
-      augmentedBootstrap = obfuscateBootstrap(augmentedBootstrap);
-    }
-
-    // Read bundled entry
-    const entryContent = fs.readFileSync(bundledEntryPath, 'utf8');
-
-    // Bundle with bootstrap
-    const finalEntry = bundleEntry(entryContent, augmentedBootstrap, this.config.useSnapshot, this.verbose);
-    
-    // Write final entry
-    const finalPath = bundledEntryPath.replace('.js', '-final.js');
-    fs.writeFileSync(finalPath, finalEntry, 'utf8');
-
-    diag.success('Bootstrap prepared');
-    return finalPath;
-  }
-
-  /**
-   * Generate SEA for a specific target
-   */
-  async generateSEAForTarget(options) {
-    const {
-      assets,
-      entryPath,
-      target,
-      outputPath: outputDir,
-      executableName,
-      platform,
-      arch,
-      nodeVersion,
-      rcedit,
-      buildNumber
-    } = options;
-
-    diag.buildStep(buildNumber, 4, 'Generating SEA blob...');
-
-    // Generate manifest
-    const manifest = generateManifest(
-      assets,
-      {
-        _packageName: this.config._packageName || 'app',
-        _packageVersion: this.config._packageVersion || '1.0.0',
-        cacheLocation: this.config.cacheLocation
-      },
-      platform,
-      arch
-    );
-
-    const manifestJson = serializeManifest(manifest);
-    const manifestAsset = {
-      sourcePath: null,
-      assetKey: 'sea-manifest.json',
-      isBinary: false,
-      content: Buffer.from(manifestJson, 'utf8')
-    };
-
-    const allAssets = [...assets, manifestAsset];
-
-    // Create SEA config
-    const tempDir = path.join(this.projectRoot, 'out', '.sea-temp', target);
-    fs.mkdirSync(tempDir, { recursive: true });
-
-    const blobOutputPath = path.join(tempDir, 'sea-blob.blob');
-    const seaConfig = createSeaConfig(entryPath, blobOutputPath, allAssets, this.config);
-    
-    const seaConfigPath = path.join(tempDir, 'sea-config.json');
-    writeSeaConfigJson(seaConfig, seaConfigPath, allAssets, tempDir);
-
-    // Generate blob
-    await generateBlob(seaConfigPath, process.execPath);
-    diag.success('SEA blob generated');
-
-    // Fetch Node binary
-    diag.buildStep(buildNumber, 5, 'Fetching Node.js binary...');
-    const cacheDir = path.join(this.projectRoot, 'node_modules', '.cache', 'sea-node-binaries');
-    const nodeBinary = await fetchNodeBinary(nodeVersion, platform, arch, cacheDir);
-    diag.success('Node binary ready');
-
-    // Inject blob
-    diag.buildStep(buildNumber, 6, 'Injecting blob into executable...');
-    const outputExe = path.join(outputDir, executableName);
-    await injectBlob(nodeBinary, blobOutputPath, outputExe, platform, this.verbose, rcedit);
-
-    // Cleanup
-    if (!this.verbose) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-
-    const size = diag.formatSize(fs.statSync(outputExe).size);
-    diag.success(`Injected (${size})`);
-  }
-
-  /**
-   * Compute SHA-256 hash of a file
-   */
-  async computeHash(filePath) {
-    return new Promise((resolve, reject) => {
-      const hash = crypto.createHash('sha256');
-      const stream = fs.createReadStream(filePath);
-      stream.on('data', chunk => hash.update(chunk));
-      stream.on('end', () => resolve(hash.digest('hex')));
-      stream.on('error', reject);
-    });
-  }
-
-  /**
-   * Apply custom signing script
-   * @param {string} exePath - Path to executable
-   * @param {string} target - Build target
-   * @param {string} platform - Platform (win32, linux, darwin)
-   * @param {string} arch - Architecture (x64, arm64)
-   * @param {string} nodeVersion - Node version
-   * @param {number} buildNumber - Build number
-   */
-  async applyCustomSigning(exePath, target, platform, arch, nodeVersion, buildNumber) {
-    diag.buildStep(buildNumber, 7, 'Applying custom signing...');
-    
-    try {
-      const signScriptPath = path.resolve(this.projectRoot, this.config.sign);
-      
-      if (!fs.existsSync(signScriptPath)) {
-        throw new Error(`Signing script not found: ${signScriptPath}`);
-      }
-
-      // Dynamic import of the signing script - convert to file:// URL for Windows
-      const { pathToFileURL } = await import('url');
-      const signModuleURL = pathToFileURL(signScriptPath).href;
-      const signModule = await import(signModuleURL);
-      const signFunction = signModule.default;
-      
-      if (typeof signFunction !== 'function') {
-        throw new Error('Signing script must export a default function');
-      }
-
-      // Call the signing function with config
-      await signFunction({
-        exePath: path.resolve(exePath),
-        target,
-        platform,
-        arch,
-        nodeVersion,
-        projectRoot: this.projectRoot
-      });
-
-      diag.success('Custom signing applied');
-    } catch (error) {
-      throw new Error(`Signing failed: ${error.message}`);
-    }
-  }
-}
+/**
+ * multi-target-builder.mjs
+ * Orchestrate parallel builds for multiple target platforms.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+import Module from 'module';
+
+import { bundleWithRollup } from './rolldown-bundler.mjs';
+import { BuildCache } from './build-cache.mjs';
+import { parseTarget } from './config.mjs';
+import { generateManifest, serializeManifest } from './manifest.mjs';
+import { createSeaConfig, writeSeaConfigJson, generateBlob } from './blob.mjs';
+import { fetchNodeBinary } from './fetch-node.mjs';
+import { injectBlob } from './inject.mjs';
+import { generateEncryptionKey, encryptAssets, keyToObfuscatedCode } from './crypto-assets.mjs';
+import { obfuscateBootstrap } from './obfuscate.mjs';
+import { bundleEntry } from './entry-bundler.mjs';
+import * as diag from './diagnostics.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = Module.createRequire(import.meta.url);
+
+/**
+ * Multi-target build orchestrator
+ */
+export class MultiTargetBuilder {
+  /**
+   * @param {import('./config.mjs').SeaboxConfigV2} config - Build configuration
+   * @param {string} projectRoot - Project root directory
+   */
+  constructor(config, projectRoot = process.cwd()) {
+    this.config = config;
+    this.projectRoot = projectRoot;
+    this.cache = new BuildCache(path.join(projectRoot, 'node_modules', '.cache', '.seabox-cache'));
+    this.verbose = config.verbose || false;
+    
+    // Set verbose mode for diagnostics
+    diag.setVerbose(this.verbose);
+  }
+
+  /**
+   * Build all configured targets
+   * @returns {Promise<Array<{target: string, path: string}>>}
+   */
+  async buildAll() {
+    diag.header('Seabox Multi-Target Build');
+
+    // Step 1: Bundle entry once (platform-agnostic JavaScript)
+    const { bundledPath, nativeModules, detectedAssets } = await this.bundleEntry();
+
+    if (this.verbose && detectedAssets.size > 0) {
+      diag.separator();
+      diag.info('Auto-detected assets:');
+      for (const assetPath of detectedAssets) {
+        diag.listItem(assetPath, 1);
+      }
+    }
+
+    if (this.verbose && nativeModules.size > 0) {
+      diag.separator();
+      diag.info('Native modules detected:');
+      for (const [name, info] of nativeModules) {
+        diag.listItem(`${name}: ${info.packageRoot}`, 1);
+      }
+    }
+
+    // Step 2: Build all targets (can be parallelized)
+    diag.separator();
+    diag.info(`Building ${this.config.outputs.length} target(s)...`);
+    diag.separator();
+    
+    const buildPromises = this.config.outputs.map((output, index) =>
+      this.buildTarget(output, bundledPath, nativeModules, detectedAssets, index + 1)
+    );
+
+    const results = await Promise.all(buildPromises);
+
+    diag.summary('All builds completed successfully!');
+    
+    return results;
+  }
+
+  /**
+   * Bundle the entry file with Rollup
+   * @returns {Promise<{bundledPath: string, nativeModules: Map}>}
+   */
+  async bundleEntry() {
+    diag.step(1, 6, 'Bundling application with Rollup...');
+    
+    const entryPath = path.resolve(this.projectRoot, this.config.entry);
+    
+    if (!fs.existsSync(entryPath)) {
+      throw new Error(`Entry file not found: ${entryPath}`);
+    }
+
+    const bundledPath = path.join(this.projectRoot, 'out', '_sea-entry.js');
+    
+    // Create output directory
+    fs.mkdirSync(path.dirname(bundledPath), { recursive: true });
+
+    const result = await bundleWithRollup(
+      entryPath, 
+      bundledPath, 
+      { ...this.config, _projectRoot: this.projectRoot }, 
+      process.platform,  // Use current platform for bundling (JavaScript is platform-agnostic)
+      process.arch,
+      this.verbose
+    );
+    
+    diag.success(`Bundle created: ${bundledPath}`);
+    
+    return result;
+  }
+
+
+
+  /**
+   * Build a single target
+   * @param {import('./config.mjs').OutputTarget} outputConfig - Target configuration
+   * @param {string} bundledEntryPath - Path to bundled entry
+   * @param {Map} nativeModules - Detected native modules
+   * @param {Set<string>} detectedAssets - Auto-detected assets from bundler
+   * @param {number} buildNumber - Build number for display
+   * @returns {Promise<{target: string, path: string}>}
+   */
+  async buildTarget(outputConfig, bundledEntryPath, nativeModules, detectedAssets, buildNumber) {
+    const { target, path: outputPath, output: executableName } = outputConfig;
+    const { nodeVersion, platform, arch } = parseTarget(target);
+
+    diag.subheader(`[Build ${buildNumber}] Target: ${target}`);
+
+    // Step 1: Rebuild native modules for this target
+    const rebuiltModules = await this.rebuildNativeModulesForTarget(
+      nativeModules,
+      target,
+      buildNumber
+    );
+
+    // Step 2: Collect config assets (manual globs)
+    const configAssets = await this.collectConfigAssets(
+      this.config.assets || [],
+      buildNumber
+    );
+
+    // Step 3: Collect auto-detected assets (from path.join(__dirname, ...))
+    const autoAssets = await this.collectDetectedAssets(
+      detectedAssets,
+      buildNumber
+    );
+
+    // Step 4: Collect platform-specific libraries (DLLs/SOs)
+    const platformLibraries = await this.collectPlatformLibraries(
+      outputConfig.libraries,
+      platform,
+      arch,
+      buildNumber
+    );
+
+    // Step 5: Prepare bundled entry with bootstrap
+    const finalEntryPath = await this.prepareFinalEntry(
+      bundledEntryPath,
+      buildNumber
+    );
+
+    // Step 6: Combine all assets (dedupe by assetKey)
+    const assetMap = new Map();
+    
+    // Add in order of priority (later overwrites earlier)
+    for (const asset of [...rebuiltModules, ...configAssets, ...autoAssets, ...platformLibraries]) {
+      assetMap.set(asset.assetKey, asset);
+    }
+    
+    const allAssets = Array.from(assetMap.values());
+
+    // Verbose logging: List all embedded assets
+    if (this.verbose) {
+      diag.separator();
+      diag.verbose(`Embedded Assets (${allAssets.length} total):`, 1);
+      
+      const nativeAssets = allAssets.filter(a => a.assetKey.includes('.node'));
+      const libraryAssets = allAssets.filter(a => a.isBinary && !a.assetKey.includes('.node'));
+      const regularAssets = allAssets.filter(a => !a.isBinary);
+      
+      if (nativeAssets.length > 0) {
+        diag.verbose(`Native Modules (${nativeAssets.length}):`, 1);
+        for (const asset of nativeAssets) {
+          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
+          const displayName = path.basename(asset.assetKey);
+          diag.verbose(`- ${displayName} (${size})`, 2);
+        }
+      }
+      
+      if (libraryAssets.length > 0) {
+        diag.verbose(`Platform Libraries (${libraryAssets.length}):`, 1);
+        for (const asset of libraryAssets) {
+          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
+          diag.verbose(`- ${asset.assetKey} (${size})`, 2);
+        }
+      }
+      
+      if (regularAssets.length > 0) {
+        diag.verbose(`Regular Assets (${regularAssets.length}):`, 1);
+        for (const asset of regularAssets) {
+          const size = diag.formatSize(fs.statSync(asset.sourcePath).size);
+          diag.verbose(`- ${asset.assetKey} (${size})`, 2);
+        }
+      }
+    }
+
+    // Step 7: Generate SEA
+    await this.generateSEAForTarget({
+      assets: allAssets,
+      entryPath: finalEntryPath,
+      target,
+      outputPath,
+      executableName,
+      platform,
+      arch,
+      nodeVersion,
+      rcedit: outputConfig.rcedit,
+      buildNumber
+    });
+
+    const finalPath = path.join(outputPath, executableName);
+    diag.success(`Build complete: ${finalPath}`);
+
+    // Apply custom signing if configured
+    if (this.config.sign) {
+      await this.applyCustomSigning(finalPath, target, platform, arch, nodeVersion, buildNumber);
+    }
+
+    return {
+      target,
+      path: finalPath
+    };
+  }
+
+  /**
+   * Rebuild native modules for specific target
+   */
+  async rebuildNativeModulesForTarget(nativeModules, target, buildNumber) {
+    if (nativeModules.size === 0) {
+      return [];
+    }
+
+    diag.buildStep(buildNumber, 1, `Rebuilding ${nativeModules.size} native module(s)...`);
+
+    const rebuiltAssets = [];
+    const { platform, arch } = parseTarget(target);
+
+    for (const [moduleKey, moduleInfo] of nativeModules) {
+      const moduleName = moduleInfo.moduleName || path.basename(moduleKey, '.node');
+      
+      try {
+        // Skip rebuilding if this is already a prebuild for the target platform
+        if (moduleInfo.isPrebuild) {
+          diag.verbose(`Using prebuild: ${moduleName}`, 2);
+          
+          rebuiltAssets.push({
+            sourcePath: moduleInfo.binaryPath,
+            assetKey: moduleInfo.assetKey,  // Use original assetKey from bundler
+            isBinary: true,
+            hash: await this.computeHash(moduleInfo.binaryPath)
+          });
+          continue;
+        }
+        
+        // Check cache first
+        const cachedBuild = this.cache.getCachedNativeBuild(moduleInfo.packageRoot, target);
+        
+        if (cachedBuild) {
+          diag.verbose(`Using cached build: ${moduleName}`, 2);
+          
+          rebuiltAssets.push({
+            sourcePath: cachedBuild,
+            assetKey: moduleInfo.assetKey,  // Use original assetKey from bundler
+            isBinary: true,
+            hash: await this.computeHash(cachedBuild)
+          });
+          continue;
+        }
+
+        // Rebuild the module
+        diag.verbose(`Rebuilding: ${moduleName} for Node.js ${parseTarget(target).nodeVersion}`, 2);
+
+        await this.rebuildNativeModule(moduleInfo.packageRoot, target);
+
+        // Find the built binary
+        const builtPath = await this.findBuiltBinary(moduleInfo, target);
+        
+        if (builtPath) {
+          // Cache the build
+          this.cache.cacheNativeBuild(moduleInfo.packageRoot, target, builtPath);
+          
+          rebuiltAssets.push({
+            sourcePath: builtPath,
+            assetKey: moduleInfo.assetKey,  // Use original assetKey from bundler
+            isBinary: true,
+            hash: await this.computeHash(builtPath)
+          });
+          
+          diag.verbose(`Built: ${moduleName} -> ${builtPath}`, 2);
+        }
+      } catch (err) {
+        diag.warn(`Failed to rebuild ${moduleName}: ${err.message}`, 2);
+      }
+    }
+
+    diag.success('Native modules processed');
+    return rebuiltAssets;
+  }
+
+  /**
+   * Rebuild a single native module
+   */
+  async rebuildNativeModule(packageRoot, target) {
+    const rebuildScript = path.join(__dirname, '..', 'bin', 'seabox-rebuild.mjs');
+    
+    if (!fs.existsSync(rebuildScript)) {
+      throw new Error('seabox-rebuild.mjs not found');
+    }
+
+    const { nodeVersion, platform, arch } = parseTarget(target);
+
+    try {
+      // Always inherit stdio to show node-gyp progress (header downloads, etc.)
+      execSync(`node "${rebuildScript}" "${packageRoot}" ${nodeVersion} ${platform} ${arch}${this.verbose ? ' --verbose' : ''}`, {
+        stdio: 'inherit',  // Show node-gyp output including header downloads
+        cwd: this.projectRoot
+      });
+    } catch (err) {
+      throw new Error(`Rebuild failed: ${err.message}`);
+    }
+  }
+
+  /**
+   * Find the built .node binary
+   */
+  async findBuiltBinary(moduleInfo, target) {
+    // Try common build locations
+    const searchPaths = [
+      path.join(moduleInfo.packageRoot, 'build/Release'),
+      path.join(moduleInfo.packageRoot, 'build/Debug'),
+      moduleInfo.buildPath
+    ];
+
+    for (const searchPath of searchPaths) {
+      if (fs.existsSync(searchPath)) {
+        const files = fs.readdirSync(searchPath);
+        const nodeFile = files.find(f => f.endsWith('.node'));
+        
+        if (nodeFile) {
+          return path.join(searchPath, nodeFile);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Collect platform-specific libraries (DLLs, SOs, DYLIBs) that need filesystem extraction
+   * Only includes libraries explicitly listed in config patterns - no automatic discovery.
+   * Libraries referenced in code (e.g., path.join(__dirname, './lib/foo.dll')) are 
+   * already captured by the bundler's asset detection.
+   * 
+   * @param {string[]} libraryPatterns - Explicit glob patterns for libraries from config
+   * @param {string} platform - Target platform
+   * @param {string} arch - Target architecture
+   * @param {number} buildNumber - Build number for display
+   */
+  async collectPlatformLibraries(libraryPatterns, platform, arch, buildNumber) {
+    // Only process explicitly configured library patterns
+    // Do NOT use default patterns - this prevents automatic inclusion of unrelated DLLs
+    if (!libraryPatterns || libraryPatterns.length === 0) {
+      return [];
+    }
+
+    diag.buildStep(buildNumber, 4, `Collecting platform libraries (${platform})...`);
+
+    const { glob } = await import('glob');
+    const libraries = [];
+
+    for (const pattern of libraryPatterns) {
+      const matches = await glob(pattern, {
+        cwd: this.projectRoot,
+        nodir: true,
+        absolute: false,
+        ignore: [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/dist/**',
+          '**/build/**',
+          '**/out/**',
+          '**/bin/**',
+          '**/obj/**',
+          '**/tools/**',
+          '**/.seabox-cache/**'
+        ]
+      });
+
+      for (const match of matches) {
+        const sourcePath = path.resolve(this.projectRoot, match);
+        
+        libraries.push({
+          sourcePath,
+          assetKey: match.replace(/\\/g, '/'),
+          isBinary: true,
+          hash: await this.computeHash(sourcePath)
+        });
+      }
+    }
+
+    if (libraries.length > 0) {
+      diag.success(`Collected ${libraries.length} library file(s)`);
+    }
+
+    return libraries;
+  }
+
+  /**
+   * Collect assets from config globs
+   * @param {string[]} assetPatterns - Glob patterns for assets
+   * @param {number} buildNumber - Build number for display
+   */
+  async collectConfigAssets(assetPatterns, buildNumber) {
+    if (!assetPatterns || assetPatterns.length === 0) {
+      return [];
+    }
+
+    diag.buildStep(buildNumber, 2, 'Collecting config assets...');
+
+    const { glob } = await import('glob');
+    const assets = [];
+
+    for (const pattern of assetPatterns) {
+      const matches = await glob(pattern, {
+        cwd: this.projectRoot,
+        nodir: true,
+        absolute: false,
+        ignore: [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/dist/**',
+          '**/build/**',
+          '**/out/**',
+          '**/bin/**',
+          '**/obj/**',
+          '**/tools/**',
+          '**/.seabox-cache/**'
+        ]
+      });
+
+      for (const match of matches) {
+        const sourcePath = path.resolve(this.projectRoot, match);
+        
+        assets.push({
+          sourcePath,
+          assetKey: match.replace(/\\/g, '/'),
+          isBinary: this.isBinaryFile(sourcePath),
+          hash: await this.computeHash(sourcePath)
+        });
+      }
+    }
+
+    if (assets.length > 0) {
+      diag.success(`Collected ${assets.length} config asset(s)`);
+    }
+
+    return assets;
+  }
+
+  /**
+   * Collect auto-detected assets from bundler (path.join(__dirname, ...))
+   * @param {Set<string>} detectedAssets - Asset paths detected during bundling
+   * @param {number} buildNumber - Build number for display
+   */
+  async collectDetectedAssets(detectedAssets, buildNumber) {
+    if (!detectedAssets || detectedAssets.size === 0) {
+      return [];
+    }
+
+    diag.buildStep(buildNumber, 3, 'Processing auto-detected assets...');
+
+    const assets = [];
+
+    for (const assetKey of detectedAssets) {
+      const sourcePath = path.resolve(this.projectRoot, assetKey);
+      
+      // Verify file still exists
+      if (fs.existsSync(sourcePath)) {
+        assets.push({
+          sourcePath,
+          assetKey: assetKey,
+          isBinary: this.isBinaryFile(sourcePath),
+          hash: await this.computeHash(sourcePath)
+        });
+      }
+    }
+
+    if (assets.length > 0) {
+      diag.success(`Collected ${assets.length} auto-detected asset(s)`);
+    }
+
+    return assets;
+  }
+
+  /**
+   * Check if a file is binary based on extension
+   */
+  isBinaryFile(filePath) {
+    const binaryExtensions = ['.node', '.dll', '.so', '.dylib', '.exe', '.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.ttf', '.eot'];
+    const ext = path.extname(filePath).toLowerCase();
+    return binaryExtensions.includes(ext);
+  }
+
+  /**
+   * Prepare final entry with bootstrap
+   */
+  async prepareFinalEntry(bundledEntryPath, buildNumber) {
+    diag.buildStep(buildNumber, 3, 'Preparing bootstrap...');
+
+    const bootstrapPath = path.join(__dirname, 'bootstrap.cjs');
+    const bootstrapContent = fs.readFileSync(bootstrapPath, 'utf8');
+    
+    let augmentedBootstrap = bootstrapContent;
+
+    // Handle encryption if enabled
+    if (this.config.encryptAssets) {
+      const encryptionKey = generateEncryptionKey();
+      const keyCode = keyToObfuscatedCode(encryptionKey);
+      
+      const encryptionSetup = `
+const SEA_ENCRYPTION_KEY = ${keyCode};
+const SEA_ENCRYPTED_ASSETS = new Set([]);
+`;
+      
+      augmentedBootstrap = bootstrapContent.replace(
+        "  'use strict';",
+        "  'use strict';\n" + encryptionSetup
+      );
+      
+      diag.verbose('Encryption enabled and bootstrap obfuscated', 2);
+      
+      augmentedBootstrap = obfuscateBootstrap(augmentedBootstrap);
+    }
+
+    // Read bundled entry
+    const entryContent = fs.readFileSync(bundledEntryPath, 'utf8');
+
+    // Bundle with bootstrap
+    const finalEntry = bundleEntry(entryContent, augmentedBootstrap, this.config.useSnapshot, this.verbose);
+    
+    // Write final entry
+    const finalPath = bundledEntryPath.replace('.js', '-final.js');
+    fs.writeFileSync(finalPath, finalEntry, 'utf8');
+
+    diag.success('Bootstrap prepared');
+    return finalPath;
+  }
+
+  /**
+   * Generate SEA for a specific target
+   */
+  async generateSEAForTarget(options) {
+    const {
+      assets,
+      entryPath,
+      target,
+      outputPath: outputDir,
+      executableName,
+      platform,
+      arch,
+      nodeVersion,
+      rcedit,
+      buildNumber
+    } = options;
+
+    diag.buildStep(buildNumber, 4, 'Generating SEA blob...');
+
+    // Generate manifest
+    const manifest = generateManifest(
+      assets,
+      {
+        _packageName: this.config._packageName || 'app',
+        _packageVersion: this.config._packageVersion || '1.0.0',
+        cacheLocation: this.config.cacheLocation
+      },
+      platform,
+      arch
+    );
+
+    const manifestJson = serializeManifest(manifest);
+    const manifestAsset = {
+      sourcePath: null,
+      assetKey: 'sea-manifest.json',
+      isBinary: false,
+      content: Buffer.from(manifestJson, 'utf8')
+    };
+
+    const allAssets = [...assets, manifestAsset];
+
+    // Create SEA config
+    const tempDir = path.join(this.projectRoot, 'out', '.sea-temp', target);
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    const blobOutputPath = path.join(tempDir, 'sea-blob.blob');
+    const seaConfig = createSeaConfig(entryPath, blobOutputPath, allAssets, this.config);
+    
+    const seaConfigPath = path.join(tempDir, 'sea-config.json');
+    writeSeaConfigJson(seaConfig, seaConfigPath, allAssets, tempDir);
+
+    // Fetch Node binary FIRST - needed for blob generation
+    diag.buildStep(buildNumber, 5, 'Fetching Node.js binary...');
+    const cacheDir = path.join(this.projectRoot, 'node_modules', '.cache', 'sea-node-binaries');
+    const nodeBinary = await fetchNodeBinary(nodeVersion, platform, arch, cacheDir);
+    diag.success('Node binary ready');
+
+    // Generate blob using the TARGET Node.js binary (not current process.execPath)
+    // This is critical for snapshots - they must be built with the target Node version
+    await generateBlob(seaConfigPath, nodeBinary);
+    diag.success('SEA blob generated');
+
+    // Inject blob
+    diag.buildStep(buildNumber, 6, 'Injecting blob into executable...');
+    const outputExe = path.join(outputDir, executableName);
+    await injectBlob(nodeBinary, blobOutputPath, outputExe, platform, this.verbose, rcedit);
+
+    // Cleanup
+    if (!this.verbose) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+
+    const size = diag.formatSize(fs.statSync(outputExe).size);
+    diag.success(`Injected (${size})`);
+  }
+
+  /**
+   * Compute SHA-256 hash of a file
+   */
+  async computeHash(filePath) {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash('sha256');
+      const stream = fs.createReadStream(filePath);
+      stream.on('data', chunk => hash.update(chunk));
+      stream.on('end', () => resolve(hash.digest('hex')));
+      stream.on('error', reject);
+    });
+  }
+
+  /**
+   * Apply custom signing script
+   * @param {string} exePath - Path to executable
+   * @param {string} target - Build target
+   * @param {string} platform - Platform (win32, linux, darwin)
+   * @param {string} arch - Architecture (x64, arm64)
+   * @param {string} nodeVersion - Node version
+   * @param {number} buildNumber - Build number
+   */
+  async applyCustomSigning(exePath, target, platform, arch, nodeVersion, buildNumber) {
+    diag.buildStep(buildNumber, 7, 'Applying custom signing...');
+    
+    try {
+      const signScriptPath = path.resolve(this.projectRoot, this.config.sign);
+      
+      if (!fs.existsSync(signScriptPath)) {
+        throw new Error(`Signing script not found: ${signScriptPath}`);
+      }
+
+      // Dynamic import of the signing script - convert to file:// URL for Windows
+      const { pathToFileURL } = await import('url');
+      const signModuleURL = pathToFileURL(signScriptPath).href;
+      const signModule = await import(signModuleURL);
+      const signFunction = signModule.default;
+      
+      if (typeof signFunction !== 'function') {
+        throw new Error('Signing script must export a default function');
+      }
+
+      // Call the signing function with config
+      await signFunction({
+        exePath: path.resolve(exePath),
+        target,
+        platform,
+        arch,
+        nodeVersion,
+        projectRoot: this.projectRoot
+      });
+
+      diag.success('Custom signing applied');
+    } catch (error) {
+      throw new Error(`Signing failed: ${error.message}`);
+    }
+  }
+}