electron-incremental-update 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/{electron-CJIoO4ny.mjs → electron-BJCk7uxG.mjs}

@@ -1,4 +1,4 @@
-import { BrowserWindow, app } from "electron";
+import { app } from "electron";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -170,10 +170,11 @@ function handleUnexpectedErrors(callback) {
 	process.on("uncaughtException", callback);
 	process.on("unhandledRejection", callback);
 }
+/**
+* @deprecated No longer needed. It is embeded in `startupWithUpdater()`
+*/
 function reloadOnPreloadScriptChanged() {
-	if (isDev) process.on("message", (msg) => {
-		if (msg === "electron-vite&type=hot-reload") for (const window of BrowserWindow.getAllWindows()) window.reload();
-	});
+	console.warn("`reloadOnPreloadScriptChange()` is no longer needed. It is embeded in `startupWithUpdater()`");
 }
 
 //#endregion

package/dist/{electron-BFoZUBhU.cjs → electron-C-qmVhAt.cjs}

@@ -173,10 +173,11 @@ function handleUnexpectedErrors(callback) {
 	process.on("uncaughtException", callback);
 	process.on("unhandledRejection", callback);
 }
+/**
+* @deprecated No longer needed. It is embeded in `startupWithUpdater()`
+*/
 function reloadOnPreloadScriptChanged() {
-	if (isDev) process.on("message", (msg) => {
-		if (msg === "electron-vite&type=hot-reload") for (const window of electron.BrowserWindow.getAllWindows()) window.reload();
-	});
+	console.warn("`reloadOnPreloadScriptChange()` is no longer needed. It is embeded in `startupWithUpdater()`");
 }
 
 //#endregion

package/dist/index.cjs

@@ -1,5 +1,5 @@
 const require_version = require('./version-aPrLuz_-.cjs');
-const require_electron = require('./electron-BFoZUBhU.cjs');
+const require_electron = require('./electron-C-qmVhAt.cjs');
 let electron = require("electron");
 let node_fs = require("node:fs");
 node_fs = require_version.__toESM(node_fs);
@@ -219,7 +219,9 @@ async function autoUpdate(updater) {
 * })
 */
 function startupWithUpdater(fn) {
-	console.log(typeof fn);
+	if (require_electron.isDev) process.on("message", (msg) => {
+		if (msg === "electron-vite&type=hot-reload") for (const window of electron.BrowserWindow.getAllWindows()) window.reload();
+	});
 	return fn;
 }
 function runWithDefaultExport(mod, args) {
@@ -259,7 +261,7 @@ async function createElectronApp(appOptions = {}) {
 		if (__EIU_IS_ESM__) runWithDefaultExport(await import(`file://${mainPath}`), updaterInstance);
 		else runWithDefaultExport(require(mainPath), updaterInstance);
 	} catch (error) {
-		logger?.error("startup error, exit", error);
+		logger?.error("Fail to startup", error);
 		onStartError?.(error, logger);
 		electron.app.quit();
 	}

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { a as getPathFromAppNameAsar, f as isDev, i as getEntryVersion, r as getAppVersion, y as restartApp } from "./electron-CJIoO4ny.mjs";
+import { a as getPathFromAppNameAsar, f as isDev, i as getEntryVersion, r as getAppVersion, y as restartApp } from "./electron-BJCk7uxG.mjs";
 import { r as isUpdateJSON } from "./version--eVB2A7n.mjs";
-import { app } from "electron";
+import { BrowserWindow, app } from "electron";
 import fs from "node:fs";
 import path from "node:path";
 import { EventEmitter } from "node:events";
@@ -217,7 +217,9 @@ async function autoUpdate(updater) {
 * })
 */
 function startupWithUpdater(fn) {
-	console.log(typeof fn);
+	if (isDev) process.on("message", (msg) => {
+		if (msg === "electron-vite&type=hot-reload") for (const window of BrowserWindow.getAllWindows()) window.reload();
+	});
 	return fn;
 }
 function runWithDefaultExport(mod, args) {
@@ -257,7 +259,7 @@ async function createElectronApp(appOptions = {}) {
 		if (__EIU_IS_ESM__) runWithDefaultExport(await import(`file://${mainPath}`), updaterInstance);
 		else runWithDefaultExport(require(mainPath), updaterInstance);
 	} catch (error) {
-		logger?.error("startup error, exit", error);
+		logger?.error("Fail to startup", error);
 		onStartError?.(error, logger);
 		app.quit();
 	}

package/dist/utils.cjs

@@ -1,5 +1,5 @@
 const require_version = require('./version-aPrLuz_-.cjs');
-const require_electron = require('./electron-BFoZUBhU.cjs');
+const require_electron = require('./electron-C-qmVhAt.cjs');
 const require_zip = require('./zip-BCC7FAQ_.cjs');
 
 exports.aesDecrypt = require_zip.aesDecrypt;

package/dist/utils.d.cts

@@ -144,6 +144,9 @@ declare function getPathFromEntryAsar(...paths: string[]): string;
 * @param callback callback function
 */
 declare function handleUnexpectedErrors(callback: (err: unknown) => void): void;
+/**
+* @deprecated No longer needed. It is embeded in `startupWithUpdater()`
+*/
 declare function reloadOnPreloadScriptChanged(): void;
 //#endregion
 //#region src/utils/zip.d.ts

package/dist/utils.d.mts

@@ -144,6 +144,9 @@ declare function getPathFromEntryAsar(...paths: string[]): string;
 * @param callback callback function
 */
 declare function handleUnexpectedErrors(callback: (err: unknown) => void): void;
+/**
+* @deprecated No longer needed. It is embeded in `startupWithUpdater()`
+*/
 declare function reloadOnPreloadScriptChanged(): void;
 //#endregion
 //#region src/utils/zip.d.ts

package/dist/utils.mjs

@@ -1,4 +1,4 @@
-import { C as singleInstance, S as setPortableDataPath, _ as reloadOnPreloadScriptChanged, a as getPathFromAppNameAsar, b as setAppUserModelId, c as getPathFromPreload, d as importNative, f as isDev, g as loadPage, h as isWin, i as getEntryVersion, l as getPathFromPublic, m as isMac, n as disableHWAccForWin7, o as getPathFromEntryAsar, p as isLinux, r as getAppVersion, s as getPathFromMain, t as beautifyDevTools, u as handleUnexpectedErrors, v as requireNative, x as setPortableAppDataPath, y as restartApp } from "./electron-CJIoO4ny.mjs";
+import { C as singleInstance, S as setPortableDataPath, _ as reloadOnPreloadScriptChanged, a as getPathFromAppNameAsar, b as setAppUserModelId, c as getPathFromPreload, d as importNative, f as isDev, g as loadPage, h as isWin, i as getEntryVersion, l as getPathFromPublic, m as isMac, n as disableHWAccForWin7, o as getPathFromEntryAsar, p as isLinux, r as getAppVersion, s as getPathFromMain, t as beautifyDevTools, u as handleUnexpectedErrors, v as requireNative, x as setPortableAppDataPath, y as restartApp } from "./electron-BJCk7uxG.mjs";
 import { i as parseVersion, n as defaultVersionJsonGenerator, r as isUpdateJSON, t as defaultIsLowerVersion } from "./version--eVB2A7n.mjs";
 import { a as defaultDownloadUpdateJSON, c as resolveJson, d as defaultSignature, f as defaultVerifySignature, i as defaultDownloadText, l as aesDecrypt, n as defaultZipFile, o as downloadUtil, p as hashBuffer, r as defaultDownloadAsar, s as getHeader, t as defaultUnzipFile, u as aesEncrypt } from "./zip-Dwm7s1C9.mjs";
 

package/dist/vite.d.mts

@@ -1,4 +1,3 @@
-import "local-pkg";
 import { SpawnOptions } from "node:child_process";
 import { BuildEnvironmentOptions, InlineConfig, LibraryOptions, PluginOption, UserConfig, UserConfigFn, build } from "vite";
 
@@ -18,9 +17,6 @@ declare function convertLiteral(code: string, sourcemap?: boolean, offset?: numb
 type Promisable<T> = T | Promise<T>;
 type AnyFunction<Return = any> = (...args: any[]) => Return;
 //#endregion
-//#region src/vite/electron/utils.d.ts
-type RolldownOptions = Exclude<BuildEnvironmentOptions["rolldownOptions"], undefined>;
-//#endregion
 //#region src/vite/electron/core.d.ts
 interface ElectronOptions {
   /**
@@ -38,27 +34,17 @@ interface ElectronOptions {
     /**
     * Electron App startup function.
     * It will mount the Electron App child-process to `process.electronApp`.
-    * @param argv default value `['.', '--no-sandbox']`
-    * @param options options for `child_process.spawn`
-    * @param customElectronPkg custom electron package name (default: 'electron')
+    * - argv: electron startup arguments (default `['.', '--no-sandbox']`)
+    * - options: options for `child_process.spawn`
+    * - customElectronPkg: custom electron package name (default: `'electron'`)
     */
     startup: (argv?: string[], options?: SpawnOptions, customElectronPkg?: string) => Promise<void>; /** Reload Electron-Renderer */
     reload: () => void;
   }) => void | Promise<void>;
 }
 //#endregion
-//#region src/vite/electron/simple.d.ts
-interface ElectronSimpleOptions {
-  main: ElectronOptions;
-  preload?: Omit<ElectronOptions, "entry"> & {
-    /**
-    * Shortcut of `build.rolldownOptions.input`.
-    *
-    * Preload scripts may contain Web assets, so use the `build.rolldownOptions.input` instead `build.lib.entry`.
-    */
-    input: RolldownOptions["input"];
-  };
-}
+//#region src/vite/electron/utils.d.ts
+type RolldownOptions = Exclude<BuildEnvironmentOptions["rolldownOptions"], undefined>;
 //#endregion
 //#region src/utils/version.d.ts
 /**
@@ -123,13 +109,19 @@ interface DistinguishedName {
 }
 //#endregion
 //#region src/vite/option.d.ts
-interface ViteOverride {
+interface CommonBuildOption {
+  /**
+  * Shortcut of `build.rolldownOptions.input`
+  */
+  files: NonNullable<ElectronOptions["entry"]>;
   /**
   * Override vite options
   */
   vite?: ElectronOptions["vite"] & {
     build?: {
       outDir: never;
+      sourcemap: never;
+      minify: never;
       rolldownOptions?: {
         output?: {
           dir: never;
@@ -149,8 +141,14 @@ interface ElectronWithUpdaterOptions {
   */
   isBuild: boolean;
   /**
+  * Project root directory. Can be an absolute path, or a path relative from
+  * the location of the config file itself.
+  * @default process.cwd()
+  */
+  root?: string;
+  /**
   * Whether to generate sourcemap
-  * @default !isBuild
+  * @default !isBuild || !!process.env.VSCODE_DEBUG
   */
   sourcemap?: boolean;
   /**
@@ -177,19 +175,73 @@ interface ElectronWithUpdaterOptions {
   */
   buildVersionJson?: boolean;
   /**
+  * Addtional `external` option in `build.rolldownOptions`,
+  *
+  * If is in dev and `entry.postBuild` is not setup,
+  * external `dependencies` in `package.json` by default
+  */
+  external?: (string | RegExp)[];
+  /**
   * Options for entry (app.asar)
+  *
+  * To change output directories, use `options.updater.paths.electronDistPath` instead
   */
-  entry?: BuildEntryOption;
+  entry: {
+    /**
+    * By default, all the unbundled modules will be packaged by packager like `electron-builder`.
+    * If setup, all the `dependencies` in `package.json` will be bundled by default, and you need
+    * to manually handle the native module files.
+    *
+    * If you are using `electron-buidler`, don't forget to append `'!node_modules/**'` in
+    * electron-build config's `files` array
+    */
+    postBuild?: (args: {
+      /**
+      * Whether is in build mode
+      */
+      isBuild: boolean;
+      /**
+      * Get path from `entryOutputDirPath`
+      */
+      getPathFromEntryOutputDir: (...paths: string[]) => string;
+      /**
+      * Check exist and copy file to `entryOutputDirPath`
+      *
+      * If `to` absent, set to `basename(from)`
+      *
+      * If `skipIfExist` absent, skip copy if `to` exist
+      */
+      copyToEntryOutputDir: (options: {
+        from: string;
+        to?: string;
+        /**
+        * Skip copy if `to` exist
+        * @default true
+        */
+        skipIfExist?: boolean;
+      }) => void;
+      /**
+      * Copy specified modules to entry output dir, just like `external` option in rolldown
+      */
+      copyModules: (options: {
+        /**
+        * External Modules
+        */
+        modules: string[];
+        /**
+        * Skip copy if `to` exist
+        * @default true
+        */
+        skipIfExist?: boolean;
+      }) => void;
+    }) => Promisable<void>;
+  } & CommonBuildOption;
   /**
   * Main process options
   *
   * To change output directories, use `options.updater.paths.electronDistPath` instead
   */
   main: {
-    /**
-    * Shortcut of `build.rolldownOptions.input`
-    */
-    files: NonNullable<ElectronOptions["entry"]>;
     /**
     * Electron App startup function.
     *
@@ -199,125 +251,18 @@ interface ElectronWithUpdaterOptions {
     * @param customElectronPkg custom electron package name (default: 'electron')
     */
     onstart?: ElectronOptions["onstart"];
-  } & ViteOverride;
+  } & CommonBuildOption;
   /**
   * Preload process options
   *
   * To change output directories, use `options.updater.paths.electronDistPath` instead
   */
-  preload: {
-    /**
-    * Shortcut of `build.rolldownOptions.input`.
-    *
-    * Preload scripts may contain Web assets, so use the `build.rolldownOptions.input` instead `build.lib.entry`.
-    */
-    files: NonNullable<ElectronOptions["entry"]>;
-  } & ViteOverride;
+  preload?: CommonBuildOption;
   /**
   * Updater options
   */
   updater?: UpdaterOptions;
 }
-interface BuildEntryOption {
-  /**
-  * Override to minify on entry
-  * @default isBuild
-  */
-  minify?: boolean;
-  /**
-  * Override to generate sourcemap on entry
-  */
-  sourcemap?: boolean;
-  /**
-  * Path to app entry output file
-  * @default 'dist-entry'
-  */
-  outDir?: string;
-  /**
-  * Path to app entry file
-  * @default 'electron/entry.ts'
-  */
-  files?: NonNullable<ElectronOptions["entry"]>;
-  /**
-  * Skip process dynamic require
-  *
-  * Useful for `better-sqlite3` and other old packages
-  */
-  ignoreDynamicRequires?: boolean;
-  /**
-  * `external` option in `build.rolldownOptions`,
-  * default is node built-in modules or native modules.
-  *
-  * If is in dev and {@link postBuild} is not setup, will also
-  * external `dependencies` in `package.json`
-  */
-  external?: NonNullable<NonNullable<InlineConfig["build"]>["rolldownOptions"]>["external"];
-  /**
-  * Custom options for `vite` build
-  * ```ts
-  * const options = {
-  *   plugins: [esm(), bytecodePlugin()], // load on needed
-  *   build: {
-  *     sourcemap,
-  *     minify,
-  *     outDir: entryOutputDirPath,
-  *     commonjsOptions: { ignoreDynamicRequires },
-  *     rolldownOptions: { external },
-  *   },
-  *   define,
-  * }
-  * ```
-  */
-  vite?: InlineConfig;
-  /**
-  * By default, all the unbundled modules will be packaged by packager like `electron-builder`.
-  * If setup, all the `dependencies` in `package.json` will be bundled by default, and you need
-  * to manually handle the native module files.
-  *
-  * If you are using `electron-buidler`, don't forget to append `'!node_modules/**'` in
-  * electron-build config's `files` array
-  */
-  postBuild?: (args: {
-    /**
-    * Whether is in build mode
-    */
-    isBuild: boolean;
-    /**
-    * Get path from `entryOutputDirPath`
-    */
-    getPathFromEntryOutputDir: (...paths: string[]) => string;
-    /**
-    * Check exist and copy file to `entryOutputDirPath`
-    *
-    * If `to` absent, set to `basename(from)`
-    *
-    * If `skipIfExist` absent, skip copy if `to` exist
-    */
-    copyToEntryOutputDir: (options: {
-      from: string;
-      to?: string;
-      /**
-      * Skip copy if `to` exist
-      * @default true
-      */
-      skipIfExist?: boolean;
-    }) => void;
-    /**
-    * Copy specified modules to entry output dir, just like `external` option in rolldown
-    */
-    copyModules: (options: {
-      /**
-      * External Modules
-      */
-      modules: string[];
-      /**
-      * Skip copy if `to` exist
-      * @default true
-      */
-      skipIfExist?: boolean;
-    }) => void;
-  }) => Promisable<void>;
-}
 interface GeneratorOverrideFunctions {
   /**
   * Custom signature generate function
@@ -358,6 +303,11 @@ interface UpdaterOptions {
     */
     asarOutputPath?: string;
     /**
+    * Path to app entry output file
+    * @default 'dist-entry'
+    */
+    entryOutDir?: string;
+    /**
     * Path to version info output, content is {@link UpdateJSON}
     * @default `version.json`
     */
@@ -427,6 +377,17 @@ interface UpdaterOptions {
 }
 //#endregion
 //#region src/vite/core.d.ts
+interface ElectronSimpleOptions {
+  main: ElectronOptions;
+  preload?: Omit<ElectronOptions, "entry"> & {
+    /**
+    * Shortcut of `build.rolldownOptions.input`.
+    *
+    * Preload scripts may contain Web assets, so use the `build.rolldownOptions.input` instead `build.lib.entry`.
+    */
+    input: RolldownOptions["input"];
+  };
+}
 type StartupFn = NonNullable<NonNullable<ElectronSimpleOptions["main"]>["onstart"]>;
 /**
 * Startup function for debug
@@ -527,7 +488,7 @@ interface ElectronViteHelperOptions extends MakeOptional<ElectronWithUpdaterOpti
   /**
   * Config for renderer process
   */
-  renderer?: UserConfig;
+  renderer?: Omit<UserConfig, "root">;
 }
 /**
 * Vite config helper

package/dist/vite.mjs

@@ -1,6 +1,6 @@
 import { builtinModules, createRequire } from "node:module";
 import * as babel from "@babel/core";
-import { getPackageInfoSync, loadPackageJSON, loadPackageJSONSync } from "local-pkg";
+import { getPackageInfoSync, loadPackageJSON } from "local-pkg";
 import MagicString from "magic-string";
 import cp from "node:child_process";
 import fs from "node:fs";
@@ -69,7 +69,6 @@ function defaultVersionJsonGenerator(existingJson, signature, version, minimumVe
 //#region src/vite/constant.ts
 const id = "electron-incremental-updater";
 const bytecodeId = `${id}-bytecode`;
-const esmId = `${id}-esm`;
 const log = createLogger("info", { prefix: `[${id}]` });
 const bytecodeLog = createLogger("info", { prefix: `[${bytecodeId}]` });
 
@@ -221,10 +220,39 @@ function copyAndSkipIfExist(from, to, skipIfExist) {
 		log.warn(`Copy failed: ${error}`, { timestamp: true });
 	}
 }
-function resolveInputToArray(files) {
-	if (typeof files === "string") return [files];
-	if (Array.isArray(files)) return files;
-	return Object.values(files);
+
+//#endregion
+//#region src/vite/build.ts
+async function buildAsar({ version, asarOutputPath, gzipPath, electronDistPath, rendererDistPath, generateGzipFile }) {
+	await fs.promises.rename(rendererDistPath, path.join(electronDistPath, "renderer"));
+	fs.writeFileSync(path.join(electronDistPath, "version"), version);
+	await createPackage(electronDistPath, asarOutputPath);
+	const buf = await generateGzipFile(fs.readFileSync(asarOutputPath));
+	fs.writeFileSync(gzipPath, buf);
+	log.info(`Build update asar to '${gzipPath}' [${readableSize(buf.length)}]`, { timestamp: true });
+	return buf;
+}
+async function buildUpdateJson({ versionPath, privateKey, cert, version, minimumVersion, generateSignature, generateUpdateJson }, asarBuffer) {
+	let _json = {
+		beta: {
+			minimumVersion: version,
+			signature: "",
+			version
+		},
+		minimumVersion: version,
+		signature: "",
+		version
+	};
+	if (fs.existsSync(versionPath)) try {
+		const oldVersionJson = JSON.parse(fs.readFileSync(versionPath, "utf-8"));
+		if (isUpdateJSON(oldVersionJson)) _json = oldVersionJson;
+		else log.warn("Old version json is invalid, ignore it", { timestamp: true });
+	} catch {}
+	const sig = await generateSignature(asarBuffer, privateKey, cert, version);
+	_json = await generateUpdateJson(_json, sig, version, minimumVersion);
+	if (!isUpdateJSON(_json)) throw new Error("Invalid update json");
+	fs.writeFileSync(versionPath, JSON.stringify(_json, null, 2));
+	log.info(`build update json to '${versionPath}'`, { timestamp: true });
 }
 
 //#endregion
@@ -352,15 +380,14 @@ function bytecodePlugin(env, options) {
 //#endregion
 //#region src/vite/electron/utils.ts
 /** Resolve the default Vite's `InlineConfig` for build Electron-Main */
-function resolveViteConfig(options) {
-	const esmodule = (loadPackageJSONSync() ?? {}).type === "module";
+function resolveViteConfig(isESM, options) {
 	return mergeConfig({
 		configFile: false,
 		publicDir: false,
 		build: {
 			lib: options.entry && {
 				entry: options.entry,
-				formats: esmodule ? ["es"] : ["cjs"],
+				formats: isESM ? ["es"] : ["cjs"],
 				fileName: () => "[name].js"
 			},
 			outDir: "dist-electron",
@@ -377,96 +404,6 @@ function resolveViteConfig(options) {
 		define: { "process.env": "process.env" }
 	}, options?.vite || {});
 }
-function withExternalBuiltins(config) {
-	const builtins = builtinModules.filter((e) => !e.startsWith("_"));
-	builtins.push("electron", ...builtins.map((m) => `node:${m}`));
-	config.build ??= {};
-	config.build.rolldownOptions ??= {};
-	let external = config.build.rolldownOptions.external;
-	if (Array.isArray(external) || typeof external === "string" || external instanceof RegExp) external = builtins.concat(external);
-	else if (typeof external === "function") {
-		const original = external;
-		external = function(source, importer, isResolved) {
-			if (builtins.includes(source)) return true;
-			return original(source, importer, isResolved);
-		};
-	} else external = builtins;
-	config.build.rolldownOptions.external = external;
-	return config;
-}
-/**
-* @see https://github.com/vitejs/vite/blob/v4.0.1/packages/vite/src/node/constants.ts#L137-L147
-*/
-function resolveHostname(hostname) {
-	const loopbackHosts = new Set([
-		"localhost",
-		"127.0.0.1",
-		"::1",
-		"0000:0000:0000:0000:0000:0000:0000:0001"
-	]);
-	const wildcardHosts = new Set([
-		"0.0.0.0",
-		"::",
-		"0000:0000:0000:0000:0000:0000:0000:0000"
-	]);
-	return loopbackHosts.has(hostname) || wildcardHosts.has(hostname) ? "localhost" : hostname;
-}
-function resolveServerUrl(server) {
-	const addressInfo = server.httpServer?.address();
-	const isAddressInfo = (x) => x?.address;
-	if (isAddressInfo(addressInfo)) {
-		const { address, port } = addressInfo;
-		const hostname = resolveHostname(address);
-		const options = server.config.server;
-		const protocol = options.https ? "https" : "http";
-		const devBase = server.config.base;
-		const path = typeof options.open === "string" ? options.open : devBase;
-		return path.startsWith("http") ? path : `${protocol}://${hostname}:${port}${path}`;
-	}
-}
-/** @see https://github.com/vitejs/vite/blob/v5.4.9/packages/vite/src/node/build.ts#L489-L504 */
-function resolveInput(config) {
-	const options = config.build;
-	const { root } = config;
-	const libOptions = options.lib;
-	const resolve = (p) => path.resolve(root, p);
-	const input = libOptions ? options.rolldownOptions?.input || (typeof libOptions.entry === "string" ? resolve(libOptions.entry) : Array.isArray(libOptions.entry) ? libOptions.entry.map(resolve) : Object.fromEntries(Object.entries(libOptions.entry).map(([alias, file]) => [alias, resolve(file)]))) : options.rolldownOptions?.input;
-	if (input) return input;
-	const indexHtml = resolve("index.html");
-	return fs.existsSync(indexHtml) ? indexHtml : void 0;
-}
-/**
-* When run the `vite build` command, there must be an entry file.
-* If the user does not need Renderer, we need to create a temporary entry file to avoid Vite throw error.
-* @see https://github.com/vitejs/vite/blob/v5.4.9/packages/vite/src/node/config.ts#L1234-L1236
-*/
-async function mockIndexHtml(config) {
-	const { root, build } = config;
-	const output = path.resolve(root, build.outDir);
-	const content = `
-<!doctype html>
-<html lang="en">
-  <head>
-    <title>vite-plugin-electron</title>
-  </head>
-  <body>
-    <div>An entry file for electron renderer process.</div>
-  </body>
-</html>
-`.trim();
-	const index = "index.html";
-	const filepath = path.join(root, index);
-	const distpath = path.join(output, index);
-	await fs.promises.writeFile(filepath, content);
-	return {
-		async remove() {
-			await fs.promises.unlink(filepath);
-			await fs.promises.unlink(distpath);
-		},
-		filepath,
-		distpath
-	};
-}
 /**
 * Inspired `tree-kill`, implemented based on sync-api. #168
 * @see https://github.com/pkrumins/node-tree-kill/blob/v1.2.2/index.js
@@ -498,29 +435,35 @@ function killTree(tree) {
 
 //#endregion
 //#region src/vite/electron/core.ts
-function build$1(options) {
-	return build(withExternalBuiltins(resolveViteConfig(options)));
+function build$1(isESM, options) {
+	return build(resolveViteConfig(isESM, options));
 }
-function electron(options) {
+function electron(isESM, root, options) {
 	const optionsArray = Array.isArray(options) ? options : [options];
 	let userConfig;
 	let configEnv;
-	let mockdInput;
 	if (!version.startsWith("8.")) throw new Error(`[vite-plugin-electron] Vite v${version} does not support \`rolldownOptions\`, please install \`vite@>=8\` or use an earlier version of \`vite-plugin-electron\`.`);
+	async function parallelBuild(options) {
+		await Promise.all(options.map(build$1.bind(build$1, isESM)));
+	}
 	return [{
 		name: "vite-plugin-electron:dev",
 		apply: "serve",
+		configResolved(config) {
+			if (config.root !== root) throw new Error(`Renderer's root (${config.root}) is not same as electron's root (${root}). Please setup \`root\` in electron plugin`);
+		},
 		configureServer(server) {
 			server.httpServer?.once("listening", () => {
-				Object.assign(process.env, { VITE_DEV_SERVER_URL: resolveServerUrl(server) });
+				Object.assign(process.env, { VITE_DEV_SERVER_URL: server.resolvedUrls?.local[0] });
 				const entryCount = optionsArray.length;
 				let closeBundleCount = 0;
-				for (const options of optionsArray) {
+				parallelBuild(optionsArray.map((options) => {
 					options.vite ??= {};
 					options.vite.mode ??= server.config.mode;
 					options.vite.root ??= server.config.root;
 					options.vite.envDir ??= server.config.envDir;
 					options.vite.envPrefix ??= server.config.envPrefix;
+					const defaultArgs = [options.vite.root || ".", "--no-sandbox"];
 					options.vite.build ??= {};
 					if (!Object.keys(options.vite.build).includes("watch")) options.vite.build.watch = {};
 					options.vite.build.minify ??= false;
@@ -530,19 +473,21 @@ function electron(options) {
 						closeBundle() {
 							if (++closeBundleCount < entryCount) return;
 							if (options.onstart) options.onstart.call(this, {
-								startup,
+								async startup(args = defaultArgs, ...opt) {
+									await startup(args, ...opt);
+								},
 								reload() {
 									if (process.electronApp) {
 										(server.hot || server.ws).send({ type: "full-reload" });
 										startup.send("electron-vite&type=hot-reload");
-									} else startup();
+									} else startup(defaultArgs);
 								}
 							});
-							else startup();
+							else startup(defaultArgs);
 						}
 					});
-					build$1(options);
-				}
+					return options;
+				}));
 			});
 		}
 	}, {
@@ -553,19 +498,15 @@ function electron(options) {
 			configEnv = env;
 			config.base ??= "./";
 		},
-		async configResolved(config) {
-			if (resolveInput(config) == null) mockdInput = await mockIndexHtml(config);
-		},
 		async closeBundle() {
-			mockdInput?.remove();
-			for (const options of optionsArray) {
+			await parallelBuild(optionsArray.map((options) => {
 				options.vite ??= {};
 				options.vite.mode ??= configEnv.mode;
 				options.vite.root ??= userConfig.root;
 				options.vite.envDir ??= userConfig.envDir;
 				options.vite.envPrefix ??= userConfig.envPrefix;
-				await build$1(options);
-			}
+				return options;
+			}));
 		}
 	}];
 }
@@ -615,64 +556,6 @@ startup.exit = async () => {
 	});
 };
 
-//#endregion
-//#region src/vite/build.ts
-async function buildAsar({ version, asarOutputPath, gzipPath, electronDistPath, rendererDistPath, generateGzipFile }) {
-	fs.renameSync(rendererDistPath, path.join(electronDistPath, "renderer"));
-	fs.writeFileSync(path.join(electronDistPath, "version"), version);
-	await createPackage(electronDistPath, asarOutputPath);
-	const buf = await generateGzipFile(fs.readFileSync(asarOutputPath));
-	fs.writeFileSync(gzipPath, buf);
-	log.info(`Build update asar to '${gzipPath}' [${readableSize(buf.length)}]`, { timestamp: true });
-	return buf;
-}
-async function buildUpdateJson({ versionPath, privateKey, cert, version, minimumVersion, generateSignature, generateUpdateJson }, asarBuffer) {
-	let _json = {
-		beta: {
-			minimumVersion: version,
-			signature: "",
-			version
-		},
-		minimumVersion: version,
-		signature: "",
-		version
-	};
-	if (fs.existsSync(versionPath)) try {
-		const oldVersionJson = JSON.parse(fs.readFileSync(versionPath, "utf-8"));
-		if (isUpdateJSON(oldVersionJson)) _json = oldVersionJson;
-		else log.warn("Old version json is invalid, ignore it", { timestamp: true });
-	} catch {}
-	const sig = await generateSignature(asarBuffer, privateKey, cert, version);
-	_json = await generateUpdateJson(_json, sig, version, minimumVersion);
-	if (!isUpdateJSON(_json)) throw new Error("Invalid update json");
-	fs.writeFileSync(versionPath, JSON.stringify(_json, null, 2));
-	log.info(`build update json to '${versionPath}'`, { timestamp: true });
-}
-async function buildEntry({ sourcemap, minify, files, outDir, ignoreDynamicRequires, external, vite }, isESM, define, bytecodeOptions) {
-	await build$1({
-		entry: files,
-		vite: mergeConfig({
-			plugins: [bytecodeOptions && bytecodePlugin("main", bytecodeOptions)],
-			build: {
-				sourcemap,
-				minify,
-				outDir,
-				emptyOutDir: true,
-				rolldownOptions: {
-					external,
-					platform: "node",
-					output: {
-						polyfillRequire: false,
-						format: isESM ? "esm" : "cjs",
-						dynamicImportInCjs: !ignoreDynamicRequires
-					}
-				}
-			},
-			define
-		}, vite ?? {})
-	});
-}
-
 //#endregion
 //#region src/vite/electron/plugin.ts
 /**
@@ -715,34 +598,6 @@ function notBundle(options = {}) {
 	};
 }
 
-//#endregion
-//#region src/vite/electron/simple.ts
-async function electronSimple(options) {
-	const flatApiOptions = [options.main];
-	const esmodule = (await loadPackageJSON() ?? {}).type === "module";
-	if (options.preload) {
-		const { input, vite: viteConfig = {}, ...preloadOptions } = options.preload;
-		const preload = {
-			onstart(args) {
-				args.reload();
-			},
-			...preloadOptions,
-			vite: mergeConfig({ build: { rolldownOptions: {
-				input,
-				output: {
-					format: "cjs",
-					inlineDynamicImports: true,
-					entryFileNames: `[name].${esmodule ? "mjs" : "js"}`,
-					chunkFileNames: `[name].${esmodule ? "mjs" : "js"}`,
-					assetFileNames: "[name].[ext]"
-				}
-			} } }, viteConfig)
-		};
-		flatApiOptions.push(preload);
-	}
-	return electron(flatApiOptions);
-}
-
 //#endregion
 //#region src/utils/crypto.ts
 function hashBuffer(data, length) {
@@ -827,15 +682,8 @@ function parseSubjects(subject) {
 
 //#endregion
 //#region src/vite/option.ts
-async function parseOptions(isBuild, pkg, sourcemap = false, minify = false, entry = {}, options = {}) {
-	const { minify: entryMinify, sourcemap: entrySourcemap, outDir = "dist-entry", files = "electron/entry.ts", postBuild, ignoreDynamicRequires = false, external = [
-		/^node:.*/,
-		/.*\.(node|dll|dylib|so)$/,
-		"original-fs",
-		"electron",
-		...isBuild || postBuild ? [] : Object.keys("dependencies" in pkg ? pkg.dependencies : {})
-	], vite = {} } = entry;
-	const { minimumVersion = "0.0.0", paths: { asarOutputPath = `release/${pkg.name}.asar`, gzipPath = `release/${pkg.name}-${pkg.version}.asar.gz`, electronDistPath = "dist-electron", rendererDistPath = "dist", versionPath = "version.json" } = {}, keys: { privateKeyPath = "keys/private.pem", certPath = "keys/cert.pem", keyLength = 2048, certInfo: { subject = {
+async function parseUpdaterOption(pkg, options = {}) {
+	const { minimumVersion = "0.0.0", paths: { asarOutputPath = `release/${pkg.name}.asar`, gzipPath = `release/${pkg.name}-${pkg.version}.asar.gz`, entryOutDir = "dist-entry", electronDistPath = "dist-electron", rendererDistPath = "dist", versionPath = "version.json" } = {}, keys: { privateKeyPath = "keys/private.pem", certPath = "keys/cert.pem", keyLength = 2048, certInfo: { subject = {
 		commonName: pkg.name,
 		organizationName: `org.${pkg.name}`
 	}, days = 3650 } = {} } = {}, overrideGenerator: { generateGzipFile = defaultZipFile, generateSignature = defaultSignature, generateUpdateJson = defaultVersionJsonGenerator } = {} } = options;
@@ -847,15 +695,6 @@ async function parseOptions(isBuild, pkg, sourcemap = false, minify = false, ent
 		rendererDistPath,
 		generateGzipFile
 	};
-	const buildEntryOption = {
-		minify: entryMinify ?? minify,
-		sourcemap: entrySourcemap ?? sourcemap,
-		outDir,
-		files,
-		vite,
-		ignoreDynamicRequires,
-		external
-	};
 	const { privateKey, cert } = await parseKeys({
 		keyLength,
 		privateKeyPath,
@@ -865,7 +704,6 @@ async function parseOptions(isBuild, pkg, sourcemap = false, minify = false, ent
 	});
 	return {
 		buildAsarOption,
-		buildEntryOption,
 		buildVersionOption: {
 			version: pkg.version,
 			minimumVersion,
@@ -875,8 +713,8 @@ async function parseOptions(isBuild, pkg, sourcemap = false, minify = false, ent
 			generateSignature,
 			generateUpdateJson
 		},
-		postBuild,
-		cert
+		cert,
+		entryOutDir
 	};
 }
 
@@ -973,6 +811,13 @@ function parseVersionPath(versionPath) {
 	if (!versionPath.startsWith("./")) versionPath = `./${versionPath}`;
 	return new URL(versionPath, "file://").pathname.slice(1);
 }
+const defaultExternal = [
+	...builtinModules,
+	"electron",
+	/^node:/,
+	/.*\.(node|dll|dylib|so)$/,
+	"original-fs"
+];
 /**
 * Base on `./electron/simple`
 * - integrate with updater
@@ -1020,153 +865,135 @@ function parseVersionPath(versionPath) {
 * ```
 */
 async function electronWithUpdater(options) {
-	let { isBuild, entry: _entry, main: _main, preload: _preload, sourcemap = !isBuild, minify = isBuild, buildVersionJson, updater, bytecode, useNotBundle = true } = options;
-	const pkg = await loadPackageJSON();
-	if (!pkg || !pkg.version || !pkg.name || !pkg.main) {
-		log.error("package.json not found or invalid, must contains version, name and main field", { timestamp: true });
-		return;
-	}
+	let { isBuild, root = process.cwd(), external, entry: _entry, main: _main, preload: _preload, sourcemap = !isBuild || !!process.env.VSCODE_DEBUG, minify = isBuild, buildVersionJson, updater, bytecode, useNotBundle = true } = options;
+	const pkg = await loadPackageJSON(root);
+	if (!pkg || !pkg.version || !pkg.name || !pkg.main) throw new Error("package.json not found or invalid, must contains version, name and main field");
 	const isESM = pkg.type === "module";
+	const finalExternal = [...defaultExternal, ...isBuild || _entry.postBuild ? [] : external || Object.keys(pkg.dependencies || {})];
 	let bytecodeOptions = typeof bytecode === "object" ? bytecode : bytecode === true ? { enable: true } : void 0;
 	if (isESM && bytecodeOptions?.enable) throw new Error("`bytecodePlugin` does not support ES module, please remove \"type\": \"module\" in package.json");
-	const { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert } = await parseOptions(isBuild, pkg, sourcemap, minify, _entry, updater);
-	const { outDir: entryOutputDirPath, files, external } = buildEntryOption;
-	try {
-		fs.rmSync(buildAsarOption.electronDistPath, {
-			recursive: true,
-			force: true
-		});
-		fs.rmSync(entryOutputDirPath, {
-			recursive: true,
-			force: true
-		});
-	} catch {}
+	const { buildAsarOption, buildVersionOption, cert, entryOutDir } = await parseUpdaterOption(pkg, updater);
 	log.info(`Clear cache files`, { timestamp: true });
-	sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
-	const _appPath = normalizePath(path.join(entryOutputDirPath, "entry.js"));
-	if (path.resolve(normalizePath(pkg.main)) !== path.resolve(_appPath)) throw new Error(`Wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
+	await Promise.all([fs.promises.rm(buildAsarOption.electronDistPath, {
+		recursive: true,
+		force: true
+	}), fs.promises.rm(entryOutDir, {
+		recursive: true,
+		force: true
+	})]).catch(() => {});
 	const define = {
 		__EIU_ASAR_BASE_NAME__: JSON.stringify(path.basename(buildAsarOption.asarOutputPath)),
 		__EIU_ELECTRON_DIST_PATH__: JSON.stringify(normalizePath(buildAsarOption.electronDistPath)),
-		__EIU_ENTRY_DIST_PATH__: JSON.stringify(normalizePath(buildEntryOption.outDir)),
+		__EIU_ENTRY_DIST_PATH__: JSON.stringify(normalizePath(entryOutDir)),
 		__EIU_IS_DEV__: JSON.stringify(!isBuild),
 		__EIU_IS_ESM__: JSON.stringify(isESM),
 		__EIU_MAIN_FILE__: JSON.stringify(getMainFileBaseName(_main.files)),
 		__EIU_SIGNATURE_CERT__: JSON.stringify(cert),
 		__EIU_VERSION_PATH__: JSON.stringify(parseVersionPath(normalizePath(buildVersionOption.versionPath)))
 	};
-	async function _buildEntry() {
-		await buildEntry(buildEntryOption, isESM, define, bytecodeOptions);
-		log.info(`Build entry to '${entryOutputDirPath}'`, { timestamp: true });
-		await postBuild?.({
-			isBuild,
-			getPathFromEntryOutputDir(...paths) {
-				return path.join(entryOutputDirPath, ...paths);
-			},
-			copyToEntryOutputDir({ from, to = path.basename(from), skipIfExist = true }) {
-				if (!fs.existsSync(from)) {
-					log.warn(`${from} not found`, { timestamp: true });
-					return;
+	const _electronOptions = [{
+		entry: _main.files,
+		onstart: _main.onstart,
+		vite: mergeConfig({
+			plugins: [!isBuild && useNotBundle && notBundle(), bytecodeOptions && bytecodePlugin("main", bytecodeOptions)],
+			build: {
+				sourcemap,
+				minify,
+				outDir: `${buildAsarOption.electronDistPath}/main`,
+				rolldownOptions: {
+					external: finalExternal,
+					platform: "node",
+					output: { polyfillRequire: false }
 				}
-				copyAndSkipIfExist(from, path.join(entryOutputDirPath, to), skipIfExist);
 			},
-			copyModules({ modules, skipIfExist = true }) {
-				const nodeModulesPath = path.join(entryOutputDirPath, "node_modules");
-				for (const m of modules) {
-					const { rootPath } = getPackageInfoSync(m) || {};
-					if (!rootPath) {
-						log.warn(`Package '${m}' not found`, { timestamp: true });
-						continue;
+			define
+		}, _main.vite ?? {})
+	}];
+	if (_preload?.files) _electronOptions.push({
+		onstart(args) {
+			args.reload();
+		},
+		vite: mergeConfig({
+			plugins: [bytecodeOptions && bytecodePlugin("preload", bytecodeOptions)],
+			build: {
+				sourcemap: sourcemap ? "inline" : void 0,
+				minify,
+				outDir: `${buildAsarOption.electronDistPath}/preload`,
+				rolldownOptions: {
+					external: finalExternal,
+					input: _preload.files,
+					output: {
+						format: "cjs",
+						inlineDynamicImports: true,
+						polyfillRequire: false,
+						entryFileNames: `[name].${isESM ? "mjs" : "js"}`,
+						chunkFileNames: `[name].${isESM ? "mjs" : "js"}`,
+						assetFileNames: "[name].[ext]"
 					}
-					copyAndSkipIfExist(rootPath, path.join(nodeModulesPath, m), skipIfExist);
-				}
-			}
-		});
-	}
-	let isInit = false;
-	const result = [electronSimple({
-		main: {
-			entry: _main.files,
-			onstart: async (args) => {
-				if (!isInit) {
-					isInit = true;
-					await _buildEntry();
 				}
-				if (_main.onstart) await _main.onstart(args);
-				else await args.startup();
 			},
-			vite: mergeConfig({
-				plugins: [!isBuild && useNotBundle && notBundle(), bytecodeOptions && bytecodePlugin("main", bytecodeOptions)],
-				build: {
-					sourcemap,
-					minify,
-					outDir: `${buildAsarOption.electronDistPath}/main`,
-					rolldownOptions: {
-						external,
-						output: {
-							polyfillRequire: false,
-							format: isESM ? "esm" : "cjs"
-						}
-					}
-				},
-				define
-			}, _main.vite ?? {})
-		},
-		preload: {
-			input: _preload.files,
-			vite: mergeConfig({
-				plugins: [bytecodeOptions && bytecodePlugin("preload", bytecodeOptions), {
-					name: `${id}-build`,
+			define
+		}, _preload?.vite ?? {})
+	});
+	_electronOptions.push({
+		entry: _entry.files,
+		vite: mergeConfig({
+			plugins: [
+				bytecodeOptions && bytecodePlugin("main", bytecodeOptions),
+				!isBuild && useNotBundle && notBundle(),
+				{
+					name: `${id}:entry`,
 					enforce: "post",
-					apply() {
-						return isBuild;
-					},
 					async closeBundle() {
-						await _buildEntry();
-						const buffer = await buildAsar(buildAsarOption);
-						if (!buildVersionJson && !isCI) log.warn("No `buildVersionJson` option setup, skip build version json. Only build in CI by default", { timestamp: true });
-						else await buildUpdateJson(buildVersionOption, buffer);
-					}
-				}],
-				build: {
-					sourcemap: sourcemap ? "inline" : void 0,
-					minify,
-					outDir: `${buildAsarOption.electronDistPath}/preload`,
-					rolldownOptions: {
-						external,
-						output: { polyfillRequire: false }
+						log.info(`Build entry to '${entryOutDir}'`, { timestamp: true });
+						await _entry.postBuild?.({
+							isBuild,
+							getPathFromEntryOutputDir(...paths) {
+								return path.join(entryOutDir, ...paths);
+							},
+							copyToEntryOutputDir({ from, to = path.basename(from), skipIfExist = true }) {
+								if (!fs.existsSync(from)) {
+									log.warn(`${from} not found`, { timestamp: true });
+									return;
+								}
+								copyAndSkipIfExist(from, path.join(entryOutDir, to), skipIfExist);
+							},
+							copyModules({ modules, skipIfExist = true }) {
+								const nodeModulesPath = path.join(entryOutDir, "node_modules");
+								for (const m of modules) {
+									const { rootPath } = getPackageInfoSync(m) || {};
+									if (!rootPath) {
+										log.warn(`Package '${m}' not found`, { timestamp: true });
+										continue;
+									}
+									copyAndSkipIfExist(rootPath, path.join(nodeModulesPath, m), skipIfExist);
+								}
+							}
+						});
+						if (isBuild) try {
+							const buffer = await buildAsar(buildAsarOption);
+							if (!buildVersionJson && !isCI) log.warn("No `buildVersionJson` option setup, skip build version json. Only build in CI by default", { timestamp: true });
+							else await buildUpdateJson(buildVersionOption, buffer);
+						} catch (error) {
+							console.error(error);
+						}
 					}
-				},
-				define
-			}, _preload?.vite ?? {})
-		}
-	})];
-	if (files) {
-		const watchFiles = resolveInputToArray(files).map((file) => path.resolve(normalizePath(file)));
-		result.push({
-			name: `${id}-dev`,
-			apply() {
-				return !isBuild;
+				}
+			],
+			build: {
+				sourcemap,
+				minify,
+				outDir: entryOutDir,
+				rolldownOptions: {
+					external: finalExternal,
+					platform: "node",
+					output: { polyfillRequire: false }
+				}
 			},
-			configureServer(server) {
-				server.watcher.add(watchFiles).on("change", async (p) => {
-					if (!watchFiles.includes(p)) return;
-					await _buildEntry();
-					if (_main.onstart) await _main.onstart({
-						startup,
-						reload: () => {
-							if (process.electronApp) {
-								(server.hot || server.ws).send({ type: "full-reload" });
-								startup.send("electron-vite&type=hot-reload");
-							} else startup();
-						}
-					});
-					else await startup();
-				});
-			}
-		});
-	}
-	return result;
+			define
+		}, _entry.vite || {})
+	});
+	return electron(isESM, normalizePath(path.resolve(root)), _electronOptions);
 }
 
 //#endregion
@@ -1209,6 +1036,7 @@ function defineElectronConfig(options) {
 		const result = options.renderer ?? {};
 		result.plugins ??= [];
 		result.plugins.push(electronPlugin);
+		result.root = options.root;
 		const rendererDistPath = options.updater?.paths?.rendererDistPath;
 		if (rendererDistPath) {
 			result.build ??= {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-incremental-update",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.4",
   "description": "Electron incremental update tools with Vite plugin, support bytecode protection",
   "keywords": [
     "bytecode",
@@ -60,12 +60,13 @@
   "scripts": {
     "dev": "tsdown --watch",
     "build": "tsdown",
-    "play": "cd ./playground && vite",
+    "play": "vite",
     "release": "bun run format && bun run lint && bun run test && bun run build && bumpp --all",
     "test": "bun test",
     "test:dev": "bun test --watch",
     "format": "oxfmt",
-    "lint": "oxlint --fix"
+    "lint": "oxlint --fix",
+    "qa": "oxlint --fix && oxfmt && tsc --noEmit"
   },
   "dependencies": {
     "@babel/plugin-transform-arrow-functions": "^7.27.1",