ee-bin 5.0.0-beta.1 → 5.0.0-beta.5

package/dist/cjs/tools/serve.js

@@ -1,4 +1,25 @@
 "use strict";
+/**
+ * Dev/Build/Start Manager — ee-bin's core dispatcher
+ *
+ * The ServeProcess class manages the full dev/build/start/exec lifecycle and is the
+ * most complex module in ee-bin. Core responsibilities:
+ *   1. dev  — Start frontend dev server + Electron process, optional watch mode with auto-rebuild
+ *   2. build — Bundle Electron code + execute electron-builder platform build commands
+ *   3. start — Start Electron in production mode
+ *   4. exec  — Execute user-defined custom commands
+ *
+ * Process management strategy:
+ *   - execProcess only tracks async ChildProcess instances (sync executions are already
+ *     complete, so there's no process to manage)
+ *   - SIGINT/SIGTERM signal handlers close all child processes and restore package.json main field
+ *   - In watch mode, debounce + tree-kill terminate the old Electron process before restarting
+ *
+ * Bundling strategy:
+ *   - bundle mode: esbuild bundles into a single file + virtual registry plugin
+ *   - copy mode: directly copies the entire electron/ directory (for non-bundling scenarios)
+ *   - After bundling, switches package.json main field to point to ./public/electron/main.js
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -41,20 +62,26 @@ const helpers_js_1 = require("../lib/helpers.js");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const esbuild_1 = require("esbuild");
-const chokidar_1 = __importDefault(require("chokidar"));
+const globby_1 = require("globby");
+const chokidar_1 = require("chokidar");
 const tree_kill_1 = __importDefault(require("tree-kill"));
 const process_1 = __importDefault(require("process"));
 const cross_spawn_1 = __importStar(require("cross-spawn"));
 const utils_js_1 = require("../lib/utils.js");
+const bundle_registry_plugin_js_1 = require("../plugins/bundle_registry_plugin.js");
 const log = (0, helpers_js_1.createDebug)('ee-bin:serve');
+/** Maximum buffer size for child processes (1GB), prevents large-output build commands from being truncated */
+const MAX_BUFFER = 1024 * 1024 * 1024;
+const ELECTRON_DIR = './electron';
+const BUNDLE_DIR = './public/electron';
+const PKG_PATH = './package.json';
 class ServeProcess {
     constructor() {
         this.execProcess = {};
-        this.electronDir = './electron';
-        this.bundleDir = './public/electron';
-        this.pkgPath = './package.json';
+        this.originalPkgMain = undefined;
         this._init();
     }
+    /** Register SIGINT/SIGTERM signal handlers to ensure child processes are closed and config is restored on exit */
     _init() {
         process_1.default.on('SIGINT', () => {
             console.log(helpers_js_1.chalk.blue('[ee-bin] ') + 'Received SIGINT. Closing processes...');
@@ -65,28 +92,47 @@ class ServeProcess {
             this._closeProcess();
         });
     }
+    /**
+     * Close all child processes, restore package.json, then exit
+     *
+     * Flow: kill all child processes → restore pkgMain → sleep 500ms → process.exit(0)
+     * NOTE: The 500ms sleep is a compromise. The ideal approach would be to listen for each
+     * child process's exit event before exiting, but that's complex to implement (multi-process
+     * racing, nested processes, etc.). If a child process doesn't close in time, it may be orphaned.
+     */
     async _closeProcess() {
-        const currentProcess = [];
         const keys = Object.keys(this.execProcess);
         for (const key of keys) {
             const p = this.execProcess[key];
             if (p && p.pid) {
-                currentProcess.push({ name: key, pid: p.pid });
+                (0, tree_kill_1.default)(p.pid);
+                log('Kill %s server, pid: %d', helpers_js_1.chalk.blue(key), p.pid);
             }
         }
+        this._restorePkgMain();
         await this.sleep(500);
-        for (const p of currentProcess) {
-            (0, tree_kill_1.default)(p.pid);
-            log('Kill %s server, pid: %d', helpers_js_1.chalk.blue(p.name), p.pid);
-        }
         process_1.default.exit(0);
     }
-    dev(options = {}) {
+    /**
+     * Dev mode — start frontend dev server + Electron process
+     *
+     * Complete flow:
+     *   1. Set NODE_ENV=dev
+     *   2. Load config, parse command names to start
+     *   3. If electron command is included:
+     *      a. First bundle Electron code (via esbuild)
+     *      b. Switch package.json main field
+     *      c. If electron.watch=true, watch electron/ directory for changes
+     *         → on change: debounce → re-bundle → kill old process → re-spawn
+     *   4. multiExec starts all commands (frontend + Electron)
+     */
+    async dev(options = {}) {
         process_1.default.env.NODE_ENV = 'dev';
         const { config, serve } = options;
         const binCfg = (0, utils_js_1.loadConfig)(config);
         const binCmd = 'dev';
-        const binCmdConfig = (binCfg[binCmd] || {});
+        const binCmdConfig = binCfg.dev;
+        // Default to starting all commands defined in dev config when none specified
         let command = serve;
         if (!command) {
             command = Object.keys(binCmdConfig).join(',');
@@ -97,52 +143,64 @@ class ServeProcess {
             command: command || '',
         };
         const cmds = (0, helpers_js_1.formatCmds)(command || '');
-        if (cmds.indexOf('electron') !== -1) {
+        if (cmds.includes('electron')) {
             const electronConfig = binCmdConfig.electron;
-            const debugging = (0, utils_js_1.getArgumentByName)('debuger', electronConfig?.args) === 'true';
-            this._switchPkgMain(debugging);
+            // Electron process needs bundled code, so bundle first before starting
+            await this.bundle(binCfg.build.electron);
+            this._switchPkgMain();
+            // Watch mode: monitor electron directory for changes, auto-rebuild + restart
             if (electronConfig?.watch) {
                 let debounceTimer = null;
                 const cmd = 'electron';
-                const watcher = chokidar_1.default.watch([this.electronDir], { persistent: true });
+                const watcher = (0, chokidar_1.watch)([ELECTRON_DIR], { persistent: true });
                 watcher.on('change', async (f) => {
                     console.log(helpers_js_1.chalk.blue('[ee-bin] [dev] ') + `File [${helpers_js_1.chalk.cyan(f)}] has been changed`);
+                    // Debounce: rapid successive file changes only trigger one rebuild
                     if (debounceTimer) {
                         clearTimeout(debounceTimer);
                     }
                     debounceTimer = setTimeout(async () => {
-                        console.log(helpers_js_1.chalk.blue('[ee-bin] [dev] ') + `Restart ${cmd}`);
-                        this.bundle(binCfg.build?.electron);
-                        const subProcess = this.execProcess[cmd];
-                        if (subProcess && subProcess.pid) {
-                            (0, tree_kill_1.default)(subProcess.pid, 'SIGKILL', (err) => {
-                                if (err) {
-                                    console.log(helpers_js_1.chalk.red('[ee-bin] [dev] ') + `Restart failed, error: ${err}`);
-                                    process_1.default.exit(-1);
-                                }
-                                delete this.execProcess[cmd];
-                                const onlyElectronOpt = {
-                                    binCmd,
-                                    binCmdConfig,
-                                    command: cmd,
-                                };
-                                this.multiExec(onlyElectronOpt);
-                            });
+                        try {
+                            console.log(helpers_js_1.chalk.blue('[ee-bin] [dev] ') + `Restart ${cmd}`);
+                            await this.bundle(binCfg.build.electron);
+                            const subProcess = this.execProcess[cmd];
+                            if (subProcess && subProcess.pid) {
+                                // Kill old Electron process (SIGKILL for forced termination), then re-spawn on success
+                                (0, tree_kill_1.default)(subProcess.pid, 'SIGKILL', (err) => {
+                                    if (err) {
+                                        console.log(helpers_js_1.chalk.red('[ee-bin] [dev] ') + `Restart failed, error: ${err}`);
+                                        process_1.default.exit(-1);
+                                    }
+                                    delete this.execProcess[cmd];
+                                    const onlyElectronOpt = {
+                                        binCmd,
+                                        binCmdConfig,
+                                        command: cmd,
+                                    };
+                                    this.multiExec(onlyElectronOpt);
+                                });
+                            }
+                        }
+                        catch (e) {
+                            console.log(helpers_js_1.chalk.red('[ee-bin] [dev] ') + `Re-bundle failed: ${e instanceof Error ? e.message : e}`);
                         }
                     }, electronConfig.delay);
                 });
             }
-            this.bundle(binCfg.build?.electron);
         }
         this.multiExec(opt);
     }
-    start(options = {}) {
+    /**
+     * Production start — directly run the Electron process (no bundling)
+     * Prerequisite: the project has already been built via the build command
+     */
+    async start(options = {}) {
         process_1.default.env.NODE_ENV = 'prod';
         const { config } = options;
         const binCfg = (0, utils_js_1.loadConfig)(config);
         const binCmd = 'start';
         const binCmdConfig = {
-            start: binCfg[binCmd],
+            start: binCfg.start,
         };
         const opt = {
             binCmd,
@@ -151,28 +209,45 @@ class ServeProcess {
         };
         this.multiExec(opt);
     }
+    /** Helper: sleep for the specified number of milliseconds */
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    build(options = {}) {
+    /**
+     * Build mode — bundle Electron code + execute platform build commands
+     *
+     * Complete flow:
+     *   1. Set NODE_ENV=prod (or user-specified environment)
+     *   2. If cmds includes 'electron': bundle first → remove electron from command list → switch pkgMain
+     *   3. multiExec executes remaining commands (e.g. frontend, win64, mac, etc.)
+     *   4. After build completes, restore package.json main field
+     *
+     * The 'electron' command only triggers bundling, not an Electron process launch,
+     * so it's removed from the command list and not processed by multiExec
+     */
+    async build(options = {}) {
         const { config, env } = options;
         let { cmds } = options;
         process_1.default.env.NODE_ENV = env || 'prod';
         const binCfg = (0, utils_js_1.loadConfig)(config);
         const binCmd = 'build';
-        const binCmdConfig = (binCfg[binCmd] || {});
+        // build.electron is BundleConfig; other keys are ExecConfig.
+        // electron is always removed from commands before passing to multiExec, so this cast is safe
+        const binCmdConfig = binCfg.build;
         if (!cmds || cmds === '') {
             const tip = helpers_js_1.chalk.bgYellow('Warning') + ' Please modify the ' + helpers_js_1.chalk.blue('build') + ' property in the bin file';
             console.log(tip);
             return;
         }
         const commands = (0, helpers_js_1.formatCmds)(cmds);
-        if (commands.indexOf('electron') !== -1) {
-            this.bundle(binCfg.build?.electron);
+        if (commands.includes('electron')) {
+            await this.bundle(binCfg.build.electron);
+            // Remove 'electron' from the command list — it only triggers bundling,
+            // not a subprocess launch
             const index = commands.indexOf('electron');
             commands.splice(index, 1);
             cmds = commands.join(',');
-            this._switchPkgMain(false);
+            this._switchPkgMain();
         }
         const opt = {
             binCmd,
@@ -180,12 +255,15 @@ class ServeProcess {
             command: cmds || '',
         };
         this.multiExec(opt);
+        // Restore package.json after build completes (dev mode restores on SIGINT/SIGTERM)
+        this._restorePkgMain();
     }
+    /** Execute user-defined custom commands from the "exec" config section */
     exec(options = {}) {
         const { config, cmds } = options;
         const binCfg = (0, utils_js_1.loadConfig)(config);
         const binCmd = 'exec';
-        const binCmdConfig = (binCfg[binCmd] || {});
+        const binCmdConfig = binCfg.exec;
         const opt = {
             binCmd,
             binCmdConfig,
@@ -193,6 +271,15 @@ class ServeProcess {
         };
         this.multiExec(opt);
     }
+    /**
+     * Execute multiple commands — iterate the command list and start a subprocess for each
+     *
+     * Design decisions:
+     *   - Frontend file:// protocol is skipped in dev mode (frontend is already served via HTTP)
+     *   - sync mode uses crossSpawnSync for blocking execution; result is not stored in execProcess (process already complete)
+     *   - async mode uses crossSpawn for non-blocking execution; stored in execProcess for later kill
+     *   - async processes listen for exit events; in dev mode, a message is logged when a process exits
+     */
     multiExec(opt) {
         const { binCmd, binCmdConfig, command } = opt;
         const commands = (0, helpers_js_1.formatCmds)(command || '');
@@ -201,36 +288,47 @@ class ServeProcess {
             if (!cfg) {
                 continue;
             }
+            // In dev mode, skip frontend startup when protocol is 'file://'
+            // (frontend files are already served via HTTP dev server, no separate file:// process needed)
             if (binCmd === 'dev' && cmd === 'frontend' && cfg.protocol === 'file://') {
                 continue;
             }
             console.log(helpers_js_1.chalk.blue(`[ee-bin] [${binCmd}] `) + `Run ${helpers_js_1.chalk.green(cmd)} command`);
             console.log(helpers_js_1.chalk.blue(`[ee-bin] [${binCmd}] `) + helpers_js_1.chalk.magenta('Config:'), JSON.stringify(cfg));
             const execDir = path_1.default.join(process_1.default.cwd(), cfg.directory);
-            const execArgs = helpers_js_1.is.string(cfg.args) ? [cfg.args] : (cfg.args || []);
+            const execArgs = (0, utils_js_1.toArray)(cfg.args);
             const stdioOpt = cfg.stdio || 'inherit';
             if (cfg.sync) {
-                this.execProcess[cmd] = (0, cross_spawn_1.sync)(cfg.cmd, execArgs, {
+                // Sync execution: blocks until the command completes, no process tracking needed
+                const syncResult = (0, cross_spawn_1.sync)(cfg.cmd, execArgs, {
                     stdio: stdioOpt,
                     cwd: execDir,
-                    maxBuffer: 1024 * 1024 * 1024,
+                    maxBuffer: MAX_BUFFER,
                 });
+                if (syncResult.error) {
+                    throw new Error(`[ee-bin] [${binCmd}] Command "${cfg.cmd}" failed to spawn: ${syncResult.error.message}`);
+                }
+                if (syncResult.status !== 0 && syncResult.status !== null) {
+                    throw new Error(`[ee-bin] [${binCmd}] Command "${cfg.cmd} ${execArgs.join(' ')}" exited with code ${syncResult.status}`);
+                }
             }
             else {
-                this.execProcess[cmd] = (0, cross_spawn_1.default)(cfg.cmd, execArgs, {
+                // Async execution: starts a child process and tracks it for SIGINT/SIGTERM kill
+                const childProc = (0, cross_spawn_1.default)(cfg.cmd, execArgs, {
                     stdio: stdioOpt,
                     cwd: execDir,
-                    maxBuffer: 1024 * 1024 * 1024,
+                    maxBuffer: MAX_BUFFER,
                 });
-            }
-            console.log(helpers_js_1.chalk.blue(`[ee-bin] [${binCmd}] `) +
-                'The ' +
-                helpers_js_1.chalk.green(`${cmd}`) +
-                ` command is ${cfg.sync ? 'run completed' : 'running'}`);
-            if (!cfg.sync) {
-                this.execProcess[cmd].on('exit', () => {
+                this.execProcess[cmd] = childProc;
+                childProc.on('error', (err) => {
+                    console.log(helpers_js_1.chalk.red(`[ee-bin] [${binCmd}] `) + `Command "${cmd}" failed to spawn: ${err.message}`);
+                    delete this.execProcess[cmd];
+                });
+                childProc.on('exit', () => {
                     if (binCmd === 'dev') {
                         console.log(helpers_js_1.chalk.blue(`[ee-bin] [${binCmd}] `) + `The ${helpers_js_1.chalk.green(cmd)} process is exiting`);
+                        // On Windows, Electron exit doesn't always terminate the parent process,
+                        // so remind the user to press Ctrl+C
                         if (process_1.default.platform === 'win32' && cmd === 'electron') {
                             console.log(helpers_js_1.chalk.blue(`[ee-bin] [${binCmd}] `) + helpers_js_1.chalk.green('Press "CTRL+C" to exit'));
                         }
@@ -239,45 +337,272 @@ class ServeProcess {
                     console.log(helpers_js_1.chalk.blue(`[ee-bin] [${binCmd}] `) + `The ${helpers_js_1.chalk.green(cmd)} command has been executed and exited`);
                 });
             }
+            console.log(helpers_js_1.chalk.blue(`[ee-bin] [${binCmd}] `) +
+                'The ' +
+                helpers_js_1.chalk.green(`${cmd}`) +
+                ` command is ${cfg.sync ? 'run completed' : 'running'}`);
         }
     }
-    bundle(bundleConfig) {
+    /**
+     * Bundle Electron main process code
+     *
+     * Two modes:
+     *   - 'bundle': Use esbuild + bundleRegistryPlugin to bundle into a single file
+     *   - 'copy':   Directly copy the entire electron/ directory to public/electron/
+     *
+     * Clears the output directory (rm outdir) before bundling to ensure a clean build
+     */
+    async bundle(bundleConfig) {
         if (!bundleConfig)
             return;
-        const bundleType = bundleConfig.bundleType;
-        if (bundleType === 'copy') {
-            const srcResource = path_1.default.join(process_1.default.cwd(), this.electronDir);
-            const destResource = path_1.default.join(process_1.default.cwd(), this.bundleDir);
-            (0, utils_js_1.rm)(destResource);
-            (0, helpers_js_1.copyDirSync)(srcResource, destResource);
+        const cwd = process_1.default.cwd();
+        const outdir = path_1.default.join(cwd, BUNDLE_DIR);
+        // Clean output directory to ensure fresh build results
+        (0, utils_js_1.rm)(outdir);
+        if (bundleConfig.bundleType === 'copy') {
+            (0, helpers_js_1.copyDirSync)(path_1.default.join(cwd, ELECTRON_DIR), outdir);
         }
         else {
-            const type = bundleConfig.type || 'javascript';
-            const esbuildOptions = bundleConfig[type];
-            if (esbuildOptions) {
-                log('esbuild options:%O', esbuildOptions);
-                (0, esbuild_1.buildSync)(esbuildOptions);
-            }
+            await this._bundleWithRegistry(bundleConfig);
         }
     }
-    _switchPkgMain(isDebugger = false) {
-        let mainFile = 'main.js';
-        const pkgPath = path_1.default.join(process_1.default.cwd(), this.pkgPath);
-        const pkg = (0, utils_js_1.readJsonSync)(pkgPath);
-        const maints = path_1.default.join(process_1.default.cwd(), this.electronDir, 'main.ts');
-        if (fs_1.default.existsSync(maints)) {
-            mainFile = 'main.ts';
+    /**
+     * Resolve the esbuild options shared by the main bundle and the per-file copy transpile.
+     *
+     * Both the bundled main.js and the separately-transpiled jobs/copy files must use identical
+     * compilation settings, otherwise main process code and job code would diverge (e.g. main.js
+     * minified but jobs not, or different module format / target / define). This method centralizes
+     * everything that should be consistent; callers add only the mode-specific keys (bundle,
+     * entryPoints/outfile, externals, plugins, banner, logLevel).
+     *
+     * sourcemap auto mode: dev → inline (debuggable), prod → off (smaller output).
+     */
+    _resolveBaseBuildOptions(bundleConfig) {
+        const isDev = process_1.default.env.NODE_ENV === 'dev' || process_1.default.env.NODE_ENV === 'local';
+        let sourcemap;
+        if (bundleConfig.sourcemap === 'inline' || bundleConfig.sourcemap === true) {
+            sourcemap = 'inline';
         }
-        if (isDebugger && mainFile === 'main.js') {
-            pkg.main = this.electronDir + '/' + mainFile;
-            (0, utils_js_1.writeJsonSync)(pkgPath, pkg);
+        else if (bundleConfig.sourcemap === 'external') {
+            sourcemap = true;
         }
         else {
-            const bundleMainPath = this.bundleDir + '/' + 'main.js';
-            if (pkg.main !== bundleMainPath) {
-                pkg.main = bundleMainPath;
-                (0, utils_js_1.writeJsonSync)(pkgPath, pkg);
+            sourcemap = isDev ? 'inline' : false;
+        }
+        const format = bundleConfig.format || 'cjs';
+        return {
+            platform: 'node',
+            target: 'node20',
+            format,
+            sourcemap,
+            minify: bundleConfig.minify ?? false,
+            keepNames: bundleConfig.keepNames ?? false,
+            ...(bundleConfig.drop ? { drop: bundleConfig.drop } : {}),
+            ...(bundleConfig.legalComments ? { legalComments: bundleConfig.legalComments } : {}),
+            define: {
+                ...(bundleConfig.define || {}),
+            },
+        };
+    }
+    /**
+     * Bundle Electron code using esbuild + registry plugin
+     *
+     * esbuild configuration strategy:
+     *   - entryPoints: Virtual module 'app:bundle-entry' (generated by the plugin)
+     *   - format: Default cjs (recommended for Electron), optional esm
+     *   - sourcemap: Auto-inferred (dev→inline, prod→off), user can override
+     *   - external: Framework externals (ee-core/electron/better-sqlite3 etc.) + user-defined
+     *   - banner: Injects process.env.EE_BUNDLED = "true" so ee-core detects bundle mode
+     *   - packages: 'external' tells esbuild to automatically exclude all node_modules packages
+     *
+     * Post-bundle steps:
+     *   1. Rename output file (app_bundle-entry.js → main.js)
+     *   2. Copy non-bundlable files (jobs directory, preload/bridge.js, user-defined copy targets)
+     */
+    async _bundleWithRegistry(bundleConfig) {
+        const cwd = process_1.default.cwd();
+        const controllerDir = path_1.default.join(cwd, ELECTRON_DIR, 'controller');
+        const configDir = path_1.default.join(cwd, ELECTRON_DIR, 'config');
+        const mainJsPath = path_1.default.join(cwd, ELECTRON_DIR, 'main.js');
+        const mainTsPath = path_1.default.join(cwd, ELECTRON_DIR, 'main.ts');
+        // Detect TypeScript entry (affects esbuild resolution and output format inference)
+        const isTypeScript = fs_1.default.existsSync(mainTsPath);
+        const entryMain = isTypeScript ? mainTsPath : mainJsPath;
+        const outdir = path_1.default.join(cwd, BUNDLE_DIR);
+        const outfile = path_1.default.join(outdir, 'main.js');
+        // Framework internal externals: these packages must be loaded from node_modules at runtime,
+        // not bundled into main.js. Reasons:
+        //   - ee-core: child_process.fork() needs its entry point as a real file on disk
+        //   - electron/better-sqlite3: native modules that cannot be bundled by esbuild
+        //   - pino-roll/pino-pretty: rely on fs operations that don't work after bundling
+        const frameworkExternal = [
+            'ee-core',
+            'ee-bin',
+            'electron',
+            'better-sqlite3',
+            'proxy-agent',
+            'pino-roll',
+            'pino-pretty',
+        ];
+        const userExternal = bundleConfig.external || [];
+        const plugin = (0, bundle_registry_plugin_js_1.bundleRegistryPlugin)(controllerDir, entryMain, configDir);
+        const options = {
+            // Shared compilation settings (format/target/sourcemap/minify/keepNames/drop/legalComments/define)
+            // — kept identical to the per-file copy transpile so main.js and jobs/copy code never diverge
+            ...this._resolveBaseBuildOptions(bundleConfig),
+            // Mode-specific: bundle everything reachable from the virtual entry into a single file
+            entryPoints: ['app:bundle-entry'],
+            bundle: true,
+            // packages: 'external' tells esbuild to treat all npm packages as external
+            // (already refined by the explicit external list above)
+            packages: 'external',
+            outdir,
+            external: [
+                ...frameworkExternal,
+                ...userExternal,
+            ],
+            // Banner injects EE_BUNDLED marker: ee-core checks this value to use the registry
+            // instead of filesystem scanning when in bundle mode
+            banner: {
+                js: 'process.env.EE_BUNDLED = "true";',
+            },
+            plugins: [plugin],
+            logLevel: 'info',
+        };
+        log('_bundleWithRegistry options:%O', options);
+        await (0, esbuild_1.build)(options);
+        // esbuild replaces ':' in virtual module name 'app:bundle-entry' with '_',
+        // so the output file is named 'app_bundle-entry.js' — rename it to 'main.js'
+        const bundleEntryFile = path_1.default.join(outdir, 'app_bundle-entry.js');
+        if (fs_1.default.existsSync(bundleEntryFile)) {
+            fs_1.default.renameSync(bundleEntryFile, path_1.default.join(outdir, 'main.js'));
+        }
+        // Also rename the sourcemap file if it exists
+        const bundleEntryMap = path_1.default.join(outdir, 'app_bundle-entry.js.map');
+        if (fs_1.default.existsSync(bundleEntryMap)) {
+            fs_1.default.renameSync(bundleEntryMap, path_1.default.join(outdir, 'main.js.map'));
+        }
+        // Copy non-bundlable files (child_process.fork and BrowserWindow preload need separate files)
+        await this._copyUnbundledFiles(cwd, outdir, bundleConfig);
+        console.log(helpers_js_1.chalk.blue('[ee-bin] ') + `Bundle output: ${outfile}`);
+    }
+    /**
+     * Copy a directory or single file from electron/ to the bundle output WITH per-file transpilation.
+     *
+     * Script files (.ts/.js/.mts/.cts/.tsx/.jsx) are compiled to Node-loadable .js using
+     * esbuild with bundle:false, so their imports stay as runtime require()/import calls:
+     *   - relative imports (./foo) resolve to the sibling transpiled .js
+     *   - ee-core/* and other packages resolve from node_modules at runtime
+     * Non-script files (e.g. .json) are copied verbatim. Directory structure is preserved.
+     *
+     * @param src        Absolute path to a source directory or file
+     * @param dest       Absolute path to the destination directory (for a dir src) or file (for a file src)
+     * @param baseOptions Shared esbuild options from _resolveBaseBuildOptions — same compilation
+     *                    settings (format/target/minify/define/...) as the main bundle, so copied
+     *                    code stays consistent with main.js. bundle:false is forced for per-file output.
+     */
+    async _transpileDir(src, dest, baseOptions) {
+        if (!fs_1.default.existsSync(src))
+            return;
+        const scriptExts = new Set(['.ts', '.js', '.mts', '.cts', '.tsx', '.jsx']);
+        const transpileFile = async (srcFile, destFile) => {
+            const ext = path_1.default.extname(srcFile);
+            if (!scriptExts.has(ext)) {
+                // Non-script asset (e.g. .json): copy verbatim
+                fs_1.default.mkdirSync(path_1.default.dirname(destFile), { recursive: true });
+                fs_1.default.copyFileSync(srcFile, destFile);
+                return;
             }
+            // Output as sibling .js, preserving the directory structure. Per-file transpile (bundle:false)
+            // so imports stay as runtime require()/import calls resolved on disk.
+            await (0, esbuild_1.build)({
+                ...baseOptions,
+                entryPoints: [srcFile],
+                outfile: destFile.slice(0, -ext.length) + '.js',
+                bundle: false,
+                logLevel: 'silent',
+            });
+        };
+        // Single file: dest is the target file path
+        if (fs_1.default.statSync(src).isFile()) {
+            await transpileFile(src, dest);
+            return;
+        }
+        // Directory: walk every file, preserving the relative structure under dest
+        const entries = (0, globby_1.globbySync)('**/*', { cwd: src, onlyFiles: true });
+        for (const rel of entries) {
+            await transpileFile(path_1.default.join(src, rel), path_1.default.join(dest, rel));
+        }
+    }
+    /**
+     * Copy non-bundlable files — two-tier strategy
+     *
+     * 1. preload/bridge.js (BrowserWindow preload script must be a separate file, loaded directly by Electron)
+     * 2. Copy targets: framework defaults (jobs/) + user-defined (bundleConfig.copy), all handled
+     *    per-file by _transpileDir — script files transpiled to CJS .js (so Node's require()/
+     *    child_process.fork() can load them), other files copied verbatim, structure preserved
+     */
+    async _copyUnbundledFiles(cwd, outdir, bundleConfig) {
+        // Shared esbuild options (format/target/minify/define/...) so unbundled output stays
+        // consistent with main.js. Per-file transpile (bundle:false) is forced inside _transpileDir.
+        const baseOptions = this._resolveBaseBuildOptions(bundleConfig);
+        // preload/bridge.*: BrowserWindow's preload script is loaded directly from disk by Electron.
+        // It cannot be bundled into main.js (bundled path would be wrong, and Electron requires
+        // preload scripts to be separate files). The source may be .ts/.js/.mts/... — resolve whichever
+        // exists and transpile it to bridge.js (a plain copy would break for TypeScript sources).
+        const bridgeMatches = (0, globby_1.globbySync)('preload/bridge.{ts,js,mts,cts,tsx,jsx}', { cwd: path_1.default.join(cwd, ELECTRON_DIR) });
+        if (bridgeMatches.length > 0) {
+            const bridgeRel = bridgeMatches[0];
+            const bridgeSrc = path_1.default.join(cwd, ELECTRON_DIR, bridgeRel);
+            // dest mirrors the source basename so _transpileDir derives the sibling .js correctly
+            const bridgeDest = path_1.default.join(outdir, bridgeRel);
+            await this._transpileDir(bridgeSrc, bridgeDest, baseOptions);
+        }
+        // Copy targets kept out of main.js. jobs/ is a framework default (its files run in forked
+        // child processes loaded by ee-core's require()-based loader, which cannot execute .ts), then
+        // user-defined entries from bundleConfig.copy. De-duplicated so an explicit 'jobs' won't run twice.
+        // Script files are transpiled with the SAME esbuild options as main.js (format/target/minify/
+        // define/...), other files (assets, .json) copied verbatim — all handled per-file by _transpileDir.
+        const copyTargets = [...new Set(['jobs', ...(bundleConfig.copy || [])])];
+        for (const target of copyTargets) {
+            const src = path_1.default.join(cwd, ELECTRON_DIR, target);
+            const dest = path_1.default.join(outdir, target);
+            if (!fs_1.default.existsSync(src))
+                continue;
+            await this._transpileDir(src, dest, baseOptions);
+            console.log(helpers_js_1.chalk.blue('[ee-bin] ') + `Copied: ${dest}`);
+        }
+    }
+    /**
+     * Switch package.json main field
+     *
+     * After bundling, Electron needs to point to ./public/electron/main.js instead of
+     * ./electron/main.js, because the bundle output is in the public/electron/ directory.
+     * The original value is saved before switching so it can be restored later.
+     */
+    _switchPkgMain() {
+        const pkgPath = path_1.default.join(process_1.default.cwd(), PKG_PATH);
+        const pkg = (0, utils_js_1.readJsonSync)(pkgPath);
+        const bundleMainPath = BUNDLE_DIR + '/main.js';
+        if (pkg.main !== bundleMainPath) {
+            this.originalPkgMain = pkg.main;
+            pkg.main = bundleMainPath;
+            (0, utils_js_1.writeJsonSync)(pkgPath, pkg);
+        }
+    }
+    /**
+     * Restore package.json main field
+     *
+     * Restores the original main value after build completes or on SIGINT/SIGTERM,
+     * preventing package.json from being permanently modified (which would break dev mode)
+     */
+    _restorePkgMain() {
+        if (this.originalPkgMain !== undefined) {
+            const pkgPath = path_1.default.join(process_1.default.cwd(), PKG_PATH);
+            const pkg = (0, utils_js_1.readJsonSync)(pkgPath);
+            pkg.main = this.originalPkgMain;
+            (0, utils_js_1.writeJsonSync)(pkgPath, pkg);
+            this.originalPkgMain = undefined;
         }
     }
 }