electron-incremental-update 3.0.0-beta.5 → 3.0.0

package/dist/vite.mjs

@@ -1,51 +1,30 @@
-import { builtinModules, createRequire } from "node:module";
-import { isCI } from "ci-info";
-import { getPackageInfoSync, loadPackageJSON } from "local-pkg";
+import { builtinModules } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
-import { build, createLogger, mergeConfig, normalizePath, version } from "vite";
-import MagicString from "magic-string";
-import * as babel from "@babel/core";
-import cp from "node:child_process";
-import crypto from "node:crypto";
+import { isCI } from "ci-info";
+import { createLogger, mergeConfig, normalizePath } from "vite";
+import { electronPluginFactory } from "vite-plugin-electron/multi-env";
+import { esmShim } from "vite-plugin-electron/plugin";
 import zlib from "node:zlib";
+import crypto from "node:crypto";
+import cp from "node:child_process";
+import * as babel from "@babel/core";
+import { copyFile, cp as cp$1, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { createPackage, extractFile } from "@electron/asar";
 import { generate } from "selfsigned";
-import { createPackage } from "@electron/asar";
-
 //#region src/vite/startup.ts
 /**
-* Debug mode startup function
-* Automatically starts Electron in VSCode debug mode
-* @param args - Startup arguments
-*/
-async function debugStartup(args) {
-	if (process.env.VSCODE_DEBUG) console.log("[startup] Electron App");
-	else await args.startup();
-}
-/**
 * Filter error messages from stdout/stderr during startup
 * @param args - Startup arguments
 * @param filter - Filter function to determine which messages to show
 */
-async function filterErrorMessageStartup(args, filter) {
-	const stdio = process.platform === "linux" ? [
-		"inherit",
-		"pipe",
-		"pipe",
-		"ignore",
-		"ipc"
-	] : [
-		"inherit",
-		"pipe",
-		"pipe",
-		"ipc"
-	];
-	await args.startup(void 0, { stdio });
+async function filterErrorMessageStartup(filter) {
 	const elec = process.electronApp;
-	elec.stdout.addListener("data", (data) => {
+	elec.stdout?.addListener("data", (data) => {
 		console.log(data.toString().trimEnd());
 	});
-	elec.stderr.addListener("data", (data) => {
+	elec.stderr?.addListener("data", (data) => {
 		const message = data.toString();
 		if (filter(message)) console.error(message);
 	});
@@ -61,62 +40,51 @@ function fixWinCharEncoding(fn) {
 		await fn(...args);
 	});
 }
-
 //#endregion
-//#region src/vite/constant.ts
-const id = "electron-incremental-updater";
-const bytecodeId = `${id}-bytecode`;
-const log = createLogger("info", { prefix: `[${id}]` });
-const bytecodeLog = createLogger("info", { prefix: `[${bytecodeId}]` });
-
-//#endregion
-//#region src/vite/utils/file.ts
+//#region src/utils/compress.ts
 /**
-* Convert byte size to human-readable format
-* @param size - Size in bytes
-* @returns Human-readable size string (e.g., "1.23 MB")
+* Default function to compress file using brotli
+* @param buffer uncompressed file buffer
 */
-function readableSize(size) {
-	const units = [
-		"B",
-		"KB",
-		"MB",
-		"GB"
-	];
-	let i = 0;
-	while (size >= 1024 && i < units.length - 1) {
-		size /= 1024;
-		i++;
-	}
-	return `${size.toFixed(2)} ${units[i]}`;
+async function defaultCompressFile(buffer) {
+	return new Promise((resolve, reject) => {
+		zlib.brotliCompress(buffer, (err, buffer) => err ? reject(err) : resolve(buffer));
+	});
+}
+//#endregion
+//#region src/utils/crypto.ts
+function hashBuffer(data, length) {
+	const hash = crypto.createHash("SHA256").update(data).digest("binary");
+	return Buffer.from(hash).subarray(0, length);
+}
+function aesEncrypt(plainText, key, iv) {
+	const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+	return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
 }
 /**
-* Copy file/directory, skipping if target exists
-* @param from - Source path
-* @param to - Destination path
-* @param skipIfExist - Skip copy if destination exists
+* Default function to generate asar signature, returns generated signature
+* @param buffer file buffer
+* @param privateKey primary key
+* @param cert certificate
+* @param version target version
 */
-function copyAndSkipIfExist(from, to, skipIfExist) {
-	if (!skipIfExist || !fs.existsSync(to)) try {
-		fs.cpSync(from, to, { recursive: true });
-	} catch (error) {
-		log.warn(`Copy failed: ${error}`, { timestamp: true });
-	}
+function defaultSignature(buffer, privateKey, cert, version) {
+	return aesEncrypt(`${crypto.createSign("RSA-SHA256").update(buffer).sign(crypto.createPrivateKey(privateKey), "base64")}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
 }
-
-//#endregion
-//#region src/vite/bytecode/code.ts
-const bytecodeGeneratorScript = "const vm = require('vm')\nconst v8 = require('v8')\nconst wrap = require('module').wrap\nv8.setFlagsFromString('--no-lazy')\nv8.setFlagsFromString('--no-flush-bytecode')\nlet code = ''\nprocess.stdin.setEncoding('utf-8')\nprocess.stdin.on('readable', () => {\n  const data = process.stdin.read()\n  if (data !== null) {\n    code += data\n  }\n})\nprocess.stdin.on('end', () => {\n  try {\n    if (typeof code !== 'string') {\n      throw new Error('javascript code must be string.')\n    }\n    const script = new vm.Script(wrap(code), { produceCachedData: true })\n    const bytecodeBuffer = script.createCachedData()\n    process.stdout.write(bytecodeBuffer)\n  } catch (error) {\n    console.error(error)\n  }\n})\n";
-const bytecodeModuleLoaderCode = "\"use strict\";\nconst fs = require(\"fs\");\nconst path = require(\"path\");\nconst vm = require(\"vm\");\nconst v8 = require(\"v8\");\nconst Module = require(\"module\");\nv8.setFlagsFromString(\"--no-lazy\");\nv8.setFlagsFromString(\"--no-flush-bytecode\");\nconst FLAG_HASH_OFFSET = 12;\nconst SOURCE_HASH_OFFSET = 8;\nlet dummyBytecode;\nfunction setFlagHashHeader(bytecodeBuffer) {\n  if (!dummyBytecode) {\n    const script = new vm.Script(\"\", {\n      produceCachedData: true\n    });\n    dummyBytecode = script.createCachedData();\n  }\n  dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);\n};\nfunction getSourceHashHeader(bytecodeBuffer) {\n  return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);\n};\nfunction buffer2Number(buffer) {\n  let ret = 0;\n  ret |= buffer[3] << 24;\n  ret |= buffer[2] << 16;\n  ret |= buffer[1] << 8;\n  ret |= buffer[0];\n  return ret;\n};\nModule._extensions[\".jsc\"] = Module._extensions[\".cjsc\"] = function (module, filename) {\n  const bytecodeBuffer = fs.readFileSync(filename);\n  if (!Buffer.isBuffer(bytecodeBuffer)) {\n    throw new Error(\"BytecodeBuffer must be a buffer object.\");\n  }\n  setFlagHashHeader(bytecodeBuffer);\n  const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));\n  let dummyCode = \"\";\n  if (length > 1) {\n    dummyCode = \"\\\"\" + \"\\u200b\".repeat(length - 2) + \"\\\"\";\n  }\n  const script = new vm.Script(dummyCode, {\n    filename: filename,\n    lineOffset: 0,\n    displayErrors: true,\n    cachedData: bytecodeBuffer\n  });\n  if (script.cachedDataRejected) {\n    throw new Error(\"Invalid or incompatible cached data (cachedDataRejected)\");\n  }\n  const require = function (id) {\n    return module.require(id);\n  };\n  require.resolve = function (request, options) {\n    return Module._resolveFilename(request, module, false, options);\n  };\n  if (process.mainModule) {\n    require.main = process.mainModule;\n  }\n  require.extensions = Module._extensions;\n  require.cache = Module._cache;\n  const compiledWrapper = script.runInThisContext({\n    filename: filename,\n    lineOffset: 0,\n    columnOffset: 0,\n    displayErrors: true\n  });\n  const dirname = path.dirname(filename);\n  const args = [module.exports, require, module, filename, dirname, process, global];\n  return compiledWrapper.apply(module.exports, args);\n};\n";
-
 //#endregion
 //#region src/utils/version.ts
+const REG_VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9]+)(?:\.(\d+))?)?$/i;
 /**
 * Parse version string to {@link Version}, like `0.2.0-beta.1`
+*
+* **Supported format**: `major.minor.patch[-stage[.stageVersion]]`
+*
+* Build metadata (`+build`) and complex semver prerelease identifiers
+* (e.g. `1.0.0-beta.1.2`) are not supported yet.
 * @param version version string
 */
 function parseVersion(version) {
-	const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.exec(version);
+	const match = REG_VERSION.exec(version);
 	if (!match) throw new TypeError(`invalid version: ${version}`);
 	const [major, minor, patch] = match.slice(1, 4).map(Number);
 	const ret = {
@@ -127,9 +95,8 @@ function parseVersion(version) {
 		stageVersion: -1
 	};
 	if (match[4]) {
-		let [stage, _v] = match[4].split(".");
-		ret.stage = stage;
-		ret.stageVersion = Number(_v) || -1;
+		ret.stage = match[4];
+		ret.stageVersion = match[5] === void 0 ? -1 : Number(match[5]);
 	}
 	if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) throw new TypeError(`Invalid version: ${version}`);
 	return ret;
@@ -140,7 +107,7 @@ const is = (j) => !!(j && j.minimumVersion && j.signature && j.version);
 * @param json any variable
 */
 function isUpdateJSON(json) {
-	return is(json) && is(json?.beta);
+	return json && is(json) && is(json.beta);
 }
 /**
 * Default function to generate `UpdateJSON`
@@ -162,74 +129,141 @@ function defaultVersionJsonGenerator(existingJson, signature, version, minimumVe
 	}
 	return existingJson;
 }
-
+//#endregion
+//#region src/vite/constant.ts
+const id = "electron-incremental-update";
+const bytecodeId = `${id}-bytecode`;
+const log = createLogger("info", { prefix: `[${id}]` });
+const bytecodeLog = createLogger("info", { prefix: `[${bytecodeId}]` });
+const defaultExternal = [
+	...builtinModules,
+	"electron",
+	"electron/common",
+	"electron/main",
+	"electron/renderer",
+	"electron/utility",
+	/^node:/,
+	/.*\.(node|dll|dylib|so)$/,
+	"original-fs"
+];
+//#endregion
+//#region src/vite/bytecode/code.ts
+const bytecodeGeneratorScript = "const vm = require('vm')\nconst v8 = require('v8')\nconst wrap = require('module').wrap\nv8.setFlagsFromString('--no-lazy')\nv8.setFlagsFromString('--no-flush-bytecode')\nlet code = ''\nprocess.stdin.setEncoding('utf-8')\nprocess.stdin.on('readable', () => {\n  const data = process.stdin.read()\n  if (data !== null) {\n    code += data\n  }\n})\nprocess.stdin.on('end', () => {\n  try {\n    if (typeof code !== 'string') {\n      throw new Error('javascript code must be string.')\n    }\n    const script = new vm.Script(wrap(code), { produceCachedData: true })\n    const bytecodeBuffer = script.createCachedData()\n    process.stdout.write(bytecodeBuffer)\n  } catch (error) {\n    console.error(error)\n  }\n})\n";
+const bytecodeModuleLoaderCode = "\"use strict\";\nconst fs = require(\"fs\");\nconst path = require(\"path\");\nconst vm = require(\"vm\");\nconst v8 = require(\"v8\");\nconst Module = require(\"module\");\nv8.setFlagsFromString(\"--no-lazy\");\nv8.setFlagsFromString(\"--no-flush-bytecode\");\nconst FLAG_HASH_OFFSET = 12;\nconst SOURCE_HASH_OFFSET = 8;\nlet dummyBytecode;\nfunction setFlagHashHeader(bytecodeBuffer) {\n  if (!dummyBytecode) {\n    const script = new vm.Script(\"\", {\n      produceCachedData: true\n    });\n    dummyBytecode = script.createCachedData();\n  }\n  dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);\n};\nfunction getSourceHashHeader(bytecodeBuffer) {\n  return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);\n};\nfunction buffer2Number(buffer) {\n  let ret = 0;\n  ret |= buffer[3] << 24;\n  ret |= buffer[2] << 16;\n  ret |= buffer[1] << 8;\n  ret |= buffer[0];\n  return ret;\n};\nModule._extensions[\".jsc\"] = Module._extensions[\".cjsc\"] = function (module, filename) {\n  const bytecodeBuffer = fs.readFileSync(filename);\n  if (!Buffer.isBuffer(bytecodeBuffer)) {\n    throw new Error(\"BytecodeBuffer must be a buffer object.\");\n  }\n  setFlagHashHeader(bytecodeBuffer);\n  const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));\n  let dummyCode = \"\";\n  if (length > 1) {\n    dummyCode = \"\\\"\" + \"\\u200b\".repeat(length - 2) + \"\\\"\";\n  }\n  const script = new vm.Script(dummyCode, {\n    filename: filename,\n    lineOffset: 0,\n    displayErrors: true,\n    cachedData: bytecodeBuffer\n  });\n  if (script.cachedDataRejected) {\n    throw new Error(\"Invalid or incompatible cached data (cachedDataRejected)\");\n  }\n  const require = function (id) {\n    return module.require(id);\n  };\n  require.resolve = function (request, options) {\n    return Module._resolveFilename(request, module, false, options);\n  };\n  if (process.mainModule) {\n    require.main = process.mainModule;\n  }\n  require.extensions = Module._extensions;\n  require.cache = Module._cache;\n  const compiledWrapper = script.runInThisContext({\n    filename: filename,\n    lineOffset: 0,\n    columnOffset: 0,\n    displayErrors: true\n  });\n  const dirname = path.dirname(filename);\n  const args = [module.exports, require, module, filename, dirname, process, global];\n  return compiledWrapper.apply(module.exports, args);\n};\n";
 //#endregion
 //#region src/vite/bytecode/utils.ts
-const electronModule = getPackageInfoSync("electron");
-const electronMajorVersion = parseVersion(electronModule.version).major;
 const useStrict = "'use strict';";
 const bytecodeModuleLoader = "__loader__.js";
-function getElectronPath() {
-	const electronModulePath = electronModule.rootPath;
-	let electronExecPath = process.env.ELECTRON_EXEC_PATH || "";
-	if (!electronExecPath) {
-		if (!electronModulePath) throw new Error("Electron is not installed");
-		const pathFile = path.join(electronModulePath, "path.txt");
-		let executablePath;
-		if (fs.existsSync(pathFile)) executablePath = fs.readFileSync(pathFile, "utf-8");
-		if (executablePath) {
-			electronExecPath = path.join(electronModulePath, "dist", executablePath);
-			process.env.ELECTRON_EXEC_PATH = electronExecPath;
-		} else throw new Error("Electron executable file is not existed");
-	}
-	return electronExecPath;
+async function resolvePaths(customPath) {
+	if (!customPath || !process.CACHED_ELECTRON_PATH) process.CACHED_ELECTRON_PATH = (await import("electron")).default;
+	if (!process.CACHED_BYTECODE_COMPILER_PATH) process.CACHED_BYTECODE_COMPILER_PATH = path.join(path.dirname(process.CACHED_ELECTRON_PATH), "EIU_bytenode.cjs");
+	if (!fs.existsSync(process.CACHED_BYTECODE_COMPILER_PATH)) fs.writeFileSync(process.CACHED_BYTECODE_COMPILER_PATH, bytecodeGeneratorScript);
+	return {
+		electronPath: customPath || process.CACHED_ELECTRON_PATH,
+		bytecodePath: process.CACHED_BYTECODE_COMPILER_PATH
+	};
 }
-function getBytecodeCompilerPath() {
-	const scriptPath = path.join(electronModule.rootPath, "EIU_bytenode.cjs");
-	if (!fs.existsSync(scriptPath)) fs.writeFileSync(scriptPath, bytecodeGeneratorScript);
-	return scriptPath;
+async function compileToBytecode(code, name, customElectronPath) {
+	try {
+		const { bytecodePath, electronPath } = await resolvePaths(customElectronPath);
+		return await new Promise((resolve, reject) => {
+			const proc = cp.spawn(electronPath, [bytecodePath], {
+				env: {
+					...process.env,
+					ELECTRON_RUN_AS_NODE: "1"
+				},
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe",
+					"ipc"
+				]
+			});
+			const stdoutChunks = [];
+			const stderrChunks = [];
+			if (proc.stdin) {
+				proc.stdin.write(code);
+				proc.stdin.end();
+			}
+			if (proc.stdout) proc.stdout.on("data", (chunk_2) => stdoutChunks.push(chunk_2)).on("error", (err) => reject(err));
+			if (proc.stderr) proc.stderr.on("data", (chunk_3) => stderrChunks.push(chunk_3)).on("error", (err_1) => reject(err_1));
+			proc.on("error", (err_2) => reject(err_2));
+			proc.on("close", (exitCode) => {
+				const stdout = Buffer.concat(stdoutChunks);
+				const errorMessage = Buffer.concat(stderrChunks).toString("utf-8");
+				if (exitCode !== 0 || stdout.length === 0) {
+					reject(/* @__PURE__ */ new Error(`Bytecode generation process exited with code ${exitCode}. Error: ${errorMessage}`));
+					return;
+				}
+				resolve(stdout);
+			});
+		});
+	} catch (e) {
+		return `Failed to generate bytecode of [${name}], ${e}`;
+	}
 }
-function toRelativePath(filename, importer) {
-	const relPath = path.posix.relative(path.dirname(importer), filename);
-	return relPath.startsWith(".") ? relPath : `./${relPath}`;
+const decodeFnBody = babel.parse(";function _0xstr_(a,b){return String.fromCharCode.apply(0,a.map(function(x){return x-b}))};")?.program.body ?? [];
+function createObfuscatedStringCall(input, offset) {
+	const resolvedOffset = offset ?? ~~(Math.random() * 16) + 1;
+	const elements = input.split("").map((char) => {
+		const value = char.codePointAt(0) + resolvedOffset;
+		const node = babel.types.numericLiteral(value);
+		node.extra = {
+			raw: `0x${value.toString(16)}`,
+			rawValue: value
+		};
+		return node;
+	});
+	return babel.types.callExpression(babel.types.identifier("_0xstr_"), [babel.types.arrayExpression(elements), babel.types.numericLiteral(resolvedOffset)]);
+}
+function createPrepareContext(bytecodeFileNames) {
+	const requireRewrites = {};
+	for (const fileName of bytecodeFileNames) {
+		if (!fileName.endsWith(".js") && !fileName.endsWith(".cjs")) continue;
+		const baseName = path.posix.basename(fileName);
+		requireRewrites[baseName] = `${baseName}c`;
+	}
+	return {
+		requireRewrites,
+		hasRequireRewrites: Object.keys(requireRewrites).length > 0
+	};
 }
-function compileToBytecode(code, name, electronPath = getElectronPath()) {
-	let data = Buffer.from([]);
-	const bytecodePath = getBytecodeCompilerPath();
-	return new Promise((resolve, reject) => {
-		const proc = cp.spawn(electronPath, [bytecodePath], {
-			env: { ELECTRON_RUN_AS_NODE: "1" },
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe",
-				"ipc"
-			]
-		});
-		if (proc.stdin) {
-			proc.stdin.write(code);
-			proc.stdin.end();
-		}
-		if (proc.stdout) {
-			proc.stdout.on("data", (chunk) => data = Buffer.concat([data, chunk]));
-			proc.stdout.on("error", (err) => reject(err));
-			proc.stdout.on("end", () => resolve(data));
-		}
-		if (proc.stderr) {
-			proc.stderr.on("data", (chunk) => reject(chunk.toString()));
-			proc.stderr.on("error", (err) => reject(err));
-		}
-		proc.addListener("error", (err) => reject(err));
-		proc.on("error", (err) => reject(err));
-		proc.on("exit", () => resolve(data));
-	}).catch((e) => `Failed to generate bytecode of [${name}], ${e}`);
+function rewriteRequirePath(requirePath, requireRewrites) {
+	const baseName = path.posix.basename(requirePath);
+	const newBaseName = requireRewrites[baseName];
+	if (!newBaseName) return;
+	return `${requirePath.slice(0, -baseName.length)}${newBaseName}`;
+}
+function rewriteSimpleRequireCalls(code, requireRewrites) {
+	if (!code.includes("require(")) return code;
+	return code.replace(/\brequire\(\s*(['"])([^'"]+)\1\s*\)/g, (match, quote, requirePath) => {
+		const newRequirePath = rewriteRequirePath(requirePath, requireRewrites);
+		return newRequirePath ? `require(${quote}${newRequirePath}${quote})` : match;
+	});
 }
-function prepare(code, offset) {
-	let hasTransformed = false;
-	const transformedCode = babel.transform(code, { plugins: [
-		"@babel/plugin-transform-arrow-functions",
-		"@babel/plugin-transform-template-literals",
-		() => ({ visitor: { StringLiteral(path) {
+function obfuscateStringsPlugin(_, options) {
+	function transformProperty(path) {
+		const node = path.node;
+		if (node.computed || !babel.types.isIdentifier(node.property)) return;
+		if (path.findParent((parent) => parent.isFunctionDeclaration() && babel.types.isIdentifier(parent.node.id, { name: "_0xstr_" }))) return;
+		node.computed = true;
+		node.property = babel.types.stringLiteral(node.property.name);
+	}
+	return { visitor: {
+		MemberExpression(path) {
+			transformProperty(path);
+		},
+		OptionalMemberExpression(path) {
+			transformProperty(path);
+		},
+		ObjectProperty(path, state) {
+			const key = path.node.key;
+			if (path.node.computed || path.node.shorthand || !babel.types.isIdentifier(key) || key.name === "__proto__") return;
+			path.node.computed = true;
+			path.node.key = createObfuscatedStringCall(key.name, options.offset);
+			state.hasTransformed = true;
+		},
+		StringLiteral(path, state) {
 			const parent = path.parent;
 			const node = path.node;
 			if (parent.type === "CallExpression") {
@@ -239,409 +273,348 @@ function prepare(code, offset) {
 			if (parent.type.startsWith("Export")) return;
 			if (parent.type.startsWith("Import")) return;
 			if (parent.type === "ObjectMethod" && parent.key === node) {
-				const obfuscated = obfuscateString(node.value, offset);
-				path.parentPath.node.computed = true;
-				path.replaceWith(babel.types.identifier(obfuscated));
-				hasTransformed = true;
+				parent.computed = true;
+				path.replaceWith(createObfuscatedStringCall(node.value, options.offset));
+				state.hasTransformed = true;
 				return;
 			}
 			if (parent.type === "ObjectProperty" && parent.key === node) {
-				const obfuscated = obfuscateString(node.value, offset);
-				path.parentPath.node.computed = true;
-				path.replaceWith(babel.types.identifier(obfuscated));
-				hasTransformed = true;
+				parent.computed = true;
+				path.replaceWith(createObfuscatedStringCall(node.value, options.offset));
+				state.hasTransformed = true;
 				return;
 			}
 			if (!node.value.trim()) return;
-			path.replaceWith(babel.types.identifier(obfuscateString(node.value, offset)));
-			hasTransformed = true;
-		} } })
-	] })?.code || code;
-	return hasTransformed ? `${transformedCode}\n${decodeFn}` : transformedCode;
-}
-const decodeFn = ";function _0xstr_(a,b){return String.fromCharCode.apply(0,a.map(function(x){return x-b}))};";
-function obfuscateString(input, offset = ~~(Math.random() * 16) + 1) {
-	return `_0xstr_([${input.split("").map((c) => `0x${(c.charCodeAt(0) + offset).toString(16)}`).join(",")}],${offset})`;
+			path.replaceWith(createObfuscatedStringCall(node.value, options.offset));
+			state.hasTransformed = true;
+		},
+		Program: { exit(path, state) {
+			if (!state.hasTransformed) return;
+			path.unshiftContainer("body", decodeFnBody.map((node) => babel.types.cloneNode(node)));
+		} }
+	} };
+}
+function rewriteRequirePlugin(_, options) {
+	return { visitor: { CallExpression(path) {
+		if (!babel.types.isIdentifier(path.node.callee, { name: "require" }) || path.node.arguments.length === 0) return;
+		const arg = path.node.arguments[0];
+		if (!babel.types.isStringLiteral(arg)) return;
+		const newRequirePath = rewriteRequirePath(arg.value, options.requireRewrites);
+		if (newRequirePath) path.node.arguments[0] = babel.types.stringLiteral(newRequirePath);
+	} } };
+}
+function prepare(code, minify, context, offset) {
+	if (!code.includes("\"") && !code.includes("'") && !code.includes("`") && !code.includes("=>") && !/\.[A-Za-z_$]/.test(code) && !/[{,]\s*[A-Za-z_$][\w$]*\s*:/.test(code)) return { code };
+	if (context.hasRequireRewrites && !code.includes("`") && !code.includes("=>")) {
+		const codeWithoutSimpleRequires = code.replace(/\brequire\(\s*(['"])([^'"]+)\1\s*\)/g, "");
+		if (!codeWithoutSimpleRequires.includes("\"") && !codeWithoutSimpleRequires.includes("'")) return { code: rewriteSimpleRequireCalls(code, context.requireRewrites) };
+	}
+	return babel.transform(code, {
+		minified: minify,
+		plugins: [
+			"@babel/plugin-transform-arrow-functions",
+			"@babel/plugin-transform-template-literals",
+			[obfuscateStringsPlugin, { offset }],
+			[rewriteRequirePlugin, { requireRewrites: context.requireRewrites }]
+		]
+	});
 }
-
 //#endregion
 //#region src/vite/bytecode/index.ts
 function getBytecodeLoaderBlock(chunkFileName) {
-	return `require("${toRelativePath(bytecodeModuleLoader, normalizePath(chunkFileName))}");`;
+	const loaderFileName = path.posix.relative(path.posix.dirname(chunkFileName), bytecodeModuleLoader);
+	return `require("${loaderFileName.startsWith(".") ? loaderFileName : `./${loaderFileName}`}")`;
 }
-function checkHasBytecodeChunk(getModuleInfo, imports, dynamicImports, bytecodeChunks) {
-	const queue = [...imports, ...dynamicImports];
-	const visited = /* @__PURE__ */ new Set();
-	while (queue.length > 0) {
-		const moduleId = queue.shift();
-		if (visited.has(moduleId)) continue;
-		visited.add(moduleId);
-		if (bytecodeChunks.has(moduleId)) return true;
-		const moduleInfo = getModuleInfo(moduleId);
-		if (moduleInfo) {
-			const { importers, dynamicImporters } = moduleInfo;
-			for (const importerId of importers) if (!visited.has(importerId)) queue.push(importerId);
-			for (const importerId of dynamicImporters) if (!visited.has(importerId)) queue.push(importerId);
-		}
-	}
-	return false;
-}
-/**
-* Vite plugin that compiles JavaScript files to V8 bytecode for source code protection.
-*
-* This plugin transforms JavaScript files into bytecode format during build,
-* making the source code more difficult to reverse engineer. The generated bytecode
-* files (.jsc) can only be executed in compatible Electron environments.
-*
-* @param env - Environment type ('preload' | 'main')
-* @param options - Bytecode compilation options
-* @returns Vite plugin or null if bytecode compilation is disabled
-*/
-function bytecodePlugin(env, isESM, options) {
+function bytecodePlugin(env, minify, isESM, options) {
 	const { enable, preload = false, electronPath, beforeCompile } = options;
 	if (!enable) return null;
-	if (!preload && env === "preload") {
-		bytecodeLog.warn("`bytecodePlugin` is skiped in preload. To enable in preload, please manually set the \"enablePreload\" option to true and set `sandbox: false` when creating the window", { timestamp: true });
+	if (env === "preload" && !preload) {
+		if (preload === void 0) bytecodeLog.warn("`bytecodePlugin` is skipped in preload. Set `bytecode: { preload: false }` to disable this warning, or `bytecode: { preload: true }` and set `sandbox: false` in BrowserWindow to enable bytecode in preload.", { timestamp: true });
 		return null;
 	}
-	if (isESM) throw new Error("`bytecodePlugin` does not support ES module, please set `\"types\": \"commonjs\"` in package.json");
-	let config;
-	let bytecodeRequired = false;
-	let bytecodeFiles = [];
+	if (isESM) throw new Error("`bytecodePlugin` requires CommonJS. Set \"type\": \"commonjs\" in package.json and use .cjs extensions");
+	let hasJsChunks = false;
 	return {
-		name: `${bytecodeId}-${env}`,
-		apply: "build",
-		enforce: "post",
-		configResolved(resolvedConfig) {
-			config = resolvedConfig;
-		},
-		renderChunk(_, chunk) {
-			if (chunk.type === "chunk") bytecodeRequired = true;
-			return null;
-		},
-		generateBundle() {
-			if (bytecodeRequired) this.emitFile({
+		name: bytecodeId,
+		async generateBundle(outputOptions, bundle) {
+			hasJsChunks = Object.values(bundle).some((file) => file.type === "chunk" && (file.fileName.endsWith(".js") || file.fileName.endsWith(".cjs")));
+			if (hasJsChunks) this.emitFile({
 				type: "asset",
 				source: `${bytecodeModuleLoaderCode}\n`,
-				name: "Bytecode Loader File",
+				name: "Bytecode Loader",
 				fileName: bytecodeModuleLoader
 			});
-		},
-		async writeBundle(options, output) {
-			if (!bytecodeRequired) return;
-			const outDir = options.dir;
-			bytecodeFiles = [];
-			const bundles = Object.keys(output);
-			const chunks = Object.values(output).filter((chunk) => chunk.type === "chunk" && chunk.fileName !== bytecodeModuleLoader);
-			const bytecodeChunks = new Set(chunks.map((chunk) => chunk.fileName));
-			const pattern = chunks.filter((chunk) => !chunk.isEntry).map((chunk) => path.basename(chunk.fileName)).map((chunk) => `(${chunk})`).join("|");
-			const bytecodeRE = pattern ? new RegExp(`require\\(\\S*(?=(${pattern})\\S*\\))`, "g") : null;
-			await Promise.all(bundles.map(async (name) => {
-				const chunk = output[name];
-				if (chunk.type === "chunk") {
-					let _code = prepare(chunk.code);
-					const chunkFilePath = path.resolve(outDir, name);
-					if (beforeCompile) {
-						const cbResult = await beforeCompile(_code, chunkFilePath);
-						if (cbResult) _code = cbResult;
-					}
-					if (bytecodeRE && _code.match(bytecodeRE)) {
-						let match;
-						const s = new MagicString(_code);
-						while (match = bytecodeRE.exec(_code)) {
-							const [prefix, chunkName] = match;
-							const len = prefix.length + chunkName.length;
-							s.overwrite(match.index, match.index + len, `${prefix + chunkName}c`, { contentOnly: true });
-						}
-						_code = s.toString();
-					}
-					if (bytecodeChunks.has(name)) {
-						const result = await compileToBytecode(_code, path.join(outDir, chunk.fileName), electronPath);
-						if (typeof result === "string") throw new Error(result);
-						fs.writeFileSync(`${chunkFilePath}c`, result);
-						if (chunk.isEntry) {
-							const code = `${useStrict}\n${getBytecodeLoaderBlock(chunk.fileName)}\nmodule.exports=${`require("./${`${path.basename(name)}c`}");`}\n`;
-							fs.writeFileSync(chunkFilePath, code);
-						} else fs.unlinkSync(chunkFilePath);
-						bytecodeFiles.push({
-							name: `${name}c`,
-							size: result.length
-						});
-					} else if (chunk.isEntry) {
-						if (checkHasBytecodeChunk(this.getModuleInfo, chunk.imports, chunk.dynamicImports, bytecodeChunks)) {
-							const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
-							_code = _code.replace(/use strict(["'];)/, `$1\n${bytecodeLoaderBlock}`);
-						}
-						fs.writeFileSync(chunkFilePath, _code);
-					} else fs.writeFileSync(chunkFilePath, _code);
+			if (!hasJsChunks) return;
+			const outputDir = outputOptions.dir ?? (outputOptions.file && path.dirname(outputOptions.file));
+			const prepareContext = createPrepareContext(Object.values(bundle).filter((f) => f.type === "chunk" && !f.isEntry).map((c) => path.posix.basename(c.fileName)));
+			await Promise.all(Object.entries(bundle).map(async ([fileName, item]) => {
+				if (item.type !== "chunk" || fileName === "__loader__.js") return;
+				const chunk = item;
+				const bytecodeFileName = `${fileName}c`;
+				const absPath = outputDir ? path.join(outputDir, fileName) : fileName;
+				let code = prepare(chunk.code, minify, prepareContext)?.code || chunk.code;
+				if (beforeCompile) {
+					const hookResult = await beforeCompile(code, absPath);
+					if (hookResult) code = hookResult;
 				}
+				const bytecode = await compileToBytecode(code, absPath, electronPath);
+				if (typeof bytecode === "string") throw new TypeError(bytecode);
+				this.emitFile({
+					type: "asset",
+					source: bytecode,
+					fileName: bytecodeFileName
+				});
+				if (chunk.isEntry) chunk.code = `${useStrict}\n${getBytecodeLoaderBlock(fileName)}\nmodule.exports=require("./${path.posix.basename(fileName)}c");\n`;
+				else delete bundle[fileName];
 			}));
-		},
-		closeBundle() {
-			const outDir = `${normalizePath(path.relative(config.root, path.resolve(config.root, config.build.outDir)))}/`;
-			bytecodeFiles.forEach((file) => {
-				bytecodeLog.info(`${outDir}${file.name} [${readableSize(file.size)}]`, { timestamp: true });
-			});
-			bytecodeLog.info(`${bytecodeFiles.length} bundles compiled into bytecode.`, { timestamp: true });
-			bytecodeFiles = [];
 		}
 	};
 }
-
 //#endregion
-//#region src/vite/electron/utils.ts
-/** Resolve the default Vite's `InlineConfig` for build Electron-Main */
-function resolveViteConfig(isESM, options) {
-	return mergeConfig({
-		configFile: false,
-		publicDir: false,
-		build: {
-			lib: options.entry && {
-				entry: options.entry,
-				formats: isESM ? ["es"] : ["cjs"],
-				fileName: () => "[name].js"
-			},
-			outDir: "dist-electron",
-			emptyOutDir: false
-		},
-		resolve: {
-			conditions: ["node"],
-			mainFields: [
-				"module",
-				"jsnext:main",
-				"jsnext"
-			]
-		},
-		define: { "process.env": "process.env" }
-	}, options?.vite || {});
+//#region src/vite/local-dev-update.ts
+const LOCAL_DEV_SIGNATURE = "local-dev";
+function resolveLocalDevUpdateOptions(root, options) {
+	if (!options) return;
+	const resolvedOptions = options === true ? {} : options;
+	return {
+		baseDir: path.resolve(root, resolvedOptions.baseDir ?? "release/local-update"),
+		installedAsarPath: path.resolve(root, "DEV.asar"),
+		packageJsonPath: resolvedOptions.packageJsonPath ? path.resolve(root, resolvedOptions.packageJsonPath) : void 0,
+		chunkSize: resolvedOptions.chunkSize,
+		chunkDelay: resolvedOptions.chunkDelay
+	};
 }
-/**
-* Inspired `tree-kill`, implemented based on sync-api. #168
-* @see https://github.com/pkrumins/node-tree-kill/blob/v1.2.2/index.js
-*/
-function treeKillSync(pid) {
-	if (process.platform === "win32") cp.execSync(`taskkill /pid ${pid} /T /F`);
-	else killTree(pidTree({
-		pid,
-		ppid: process.pid
-	}));
+async function resolveLocalDevUpdatePackage(fallbackPkg, localDevUpdate) {
+	if (!localDevUpdate?.packageJsonPath) return fallbackPkg;
+	const pkg = JSON.parse(await readFile(localDevUpdate.packageJsonPath, "utf-8"));
+	if (!pkg.name || !pkg.version || !pkg.main) throw new Error("localDevUpdate.packageJsonPath must contain name, version and main fields");
+	return pkg;
 }
-function pidTree(tree) {
-	const command = process.platform === "darwin" ? `pgrep -P ${tree.pid}` : `ps -o pid --no-headers --ppid ${tree.ppid}`;
+function getNextPatchVersion(version) {
+	const parsed = parseVersion(version);
+	return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+}
+function isValidVersion(version) {
 	try {
-		const childs = cp.execSync(command, { encoding: "utf8" }).match(/\d+/g)?.map((id) => +id);
-		if (childs) tree.children = childs.map((cid) => pidTree({
-			pid: cid,
-			ppid: tree.pid
-		}));
-	} catch {}
-	return tree;
+		parseVersion(version);
+		return true;
+	} catch {
+		return false;
+	}
 }
-function killTree(tree) {
-	if (tree.children) for (const child of tree.children) killTree(child);
+function readValidAsarVersion(asarPath) {
+	try {
+		const version = extractFile(asarPath, "version").toString("utf-8").trim();
+		return isValidVersion(version) ? version : void 0;
+	} catch {
+		return;
+	}
+}
+async function installPendingAsar(installedAsarPath) {
+	const pendingAsarPath = `${installedAsarPath}.tmp`;
+	const version = readValidAsarVersion(pendingAsarPath);
+	if (!version) {
+		await rm(pendingAsarPath, { force: true });
+		return false;
+	}
 	try {
-		process.kill(tree.pid);
+		await copyFile(pendingAsarPath, installedAsarPath);
+		await rm(pendingAsarPath, { force: true });
+		log.info(`Installed pending local dev update ${version}`, { timestamp: true });
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function readExistingUpdateJSON(versionPath, version) {
+	try {
+		const json = JSON.parse(await readFile(versionPath, "utf-8"));
+		if (isUpdateJSON(json)) return json;
 	} catch {}
+	return {
+		version,
+		minimumVersion: "0.0.0",
+		signature: LOCAL_DEV_SIGNATURE,
+		beta: {
+			version,
+			minimumVersion: "0.0.0",
+			signature: LOCAL_DEV_SIGNATURE
+		}
+	};
 }
-
-//#endregion
-//#region src/vite/electron/core.ts
-function build$1(isESM, options) {
-	return build(resolveViteConfig(isESM, options));
+async function prepareLocalDevUpdateResource({ root, pkg, buildAsarOption, versionPath, minimumVersion, keepInstalledVersion, localDevUpdate }) {
+	const installedPendingUpdate = await installPendingAsar(localDevUpdate.installedAsarPath);
+	const installedVersion = readValidAsarVersion(localDevUpdate.installedAsarPath) ?? pkg.version;
+	const targetVersion = keepInstalledVersion && installedPendingUpdate ? installedVersion : getNextPatchVersion(installedVersion);
+	const workDir = await mkdtemp(path.join(tmpdir(), "eiu-local-dev-update-"));
+	const stagedElectronDistPath = path.join(workDir, "dist-electron");
+	const resolvedVersionPath = path.join(localDevUpdate.baseDir, versionPath);
+	const asarPath = path.join(localDevUpdate.baseDir, `${pkg.name}.asar`);
+	const compressedPath = path.join(localDevUpdate.baseDir, `${pkg.name}-${targetVersion}.asar.br`);
+	try {
+		await mkdir(localDevUpdate.baseDir, { recursive: true });
+		await mkdir(path.dirname(resolvedVersionPath), { recursive: true });
+		await cp$1(path.resolve(root, buildAsarOption.electronDistPath), stagedElectronDistPath, { recursive: true });
+		await writeFile(path.join(stagedElectronDistPath, "version"), targetVersion, "utf-8");
+		await createPackage(stagedElectronDistPath, asarPath);
+		await writeFile(compressedPath, await buildAsarOption.generateCompressedFile(await readFile(asarPath)));
+		const updateJSON = defaultVersionJsonGenerator(await readExistingUpdateJSON(resolvedVersionPath, targetVersion), LOCAL_DEV_SIGNATURE, targetVersion, minimumVersion);
+		if (!isUpdateJSON(updateJSON)) throw new Error("Invalid local dev update json");
+		await writeFile(resolvedVersionPath, JSON.stringify(updateJSON, null, 2), "utf-8");
+		log.info(`Prepared local dev update ${targetVersion}`, { timestamp: true });
+		return targetVersion;
+	} finally {
+		await rm(workDir, {
+			recursive: true,
+			force: true
+		});
+	}
 }
-function electron(isESM, root, options) {
-	const optionsArray = Array.isArray(options) ? options : [options];
-	let userConfig;
-	let configEnv;
-	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)));
+function createLocalDevUpdateOnstart(args) {
+	let restartRequested = false;
+	let startupArgs;
+	let managedElectronApp;
+	function createStartupArgs(onstartArgs) {
+		return {
+			...onstartArgs,
+			startup(argv, options, customElectronPkg) {
+				const env = {
+					...process.env,
+					...options?.env
+				};
+				delete env.ELECTRON_RUN_AS_NODE;
+				return onstartArgs.startup(argv, {
+					...options,
+					env
+				}, customElectronPkg);
+			}
+		};
 	}
-	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: server.resolvedUrls?.local[0] });
-				const entryCount = optionsArray.length;
-				let closeBundleCount = 0;
-				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;
-					options.vite.plugins ??= [];
-					options.vite.plugins.push({
-						name: ":startup",
-						closeBundle() {
-							if (++closeBundleCount < entryCount) return;
-							if (options.onstart) options.onstart.call(this, {
-								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(defaultArgs);
-								}
-							});
-							else startup(defaultArgs);
-						}
-					});
-					return options;
-				}));
-			});
+	async function start(onstartArgs, options = {}) {
+		const safeStartupArgs = createStartupArgs(onstartArgs);
+		startupArgs = safeStartupArgs;
+		await prepareLocalDevUpdateResource({
+			...args,
+			keepInstalledVersion: options.keepInstalledVersion
+		});
+		if (args.userOnstart) await args.userOnstart(safeStartupArgs);
+		else await safeStartupArgs.startup();
+		const electronApp = process.electronApp;
+		removeManagedListeners();
+		managedElectronApp = electronApp;
+		managedElectronApp?.removeListener("exit", process.exit);
+		managedElectronApp?.on("message", handleMessage);
+		managedElectronApp?.once("exit", handleExit);
+	}
+	function handleMessage(message) {
+		if (message === "eiu:restart") {
+			restartRequested = true;
+			managedElectronApp?.send?.("eiu:restart-ready");
 		}
-	}, {
-		name: "vite-plugin-electron:prod",
-		apply: "build",
-		config(config, env) {
-			userConfig = config;
-			configEnv = env;
-			config.base ??= "./";
-		},
-		async closeBundle() {
-			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;
-				return options;
-			}));
+	}
+	function handleExit() {
+		if (restartRequested) {
+			restartRequested = false;
+			setTimeout(() => {
+				if (startupArgs) start(startupArgs, { keepInstalledVersion: true });
+			});
+			return;
 		}
-	}];
+		process.exit();
+	}
+	function removeManagedListeners() {
+		managedElectronApp?.removeListener("message", handleMessage);
+		managedElectronApp?.removeListener("exit", handleExit);
+	}
+	return (onstartArgs) => start(onstartArgs);
 }
+//#endregion
+//#region src/vite/utils/file.ts
 /**
-* 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')
+* Convert byte size to human-readable format
+* @param size - Size in bytes
+* @returns Human-readable size string (e.g., "1.23 MB")
 */
-const startup = async (argv = [".", "--no-sandbox"], options, customElectronPkg) => {
-	const { spawn } = await import("node:child_process");
-	const electron = await import(customElectronPkg ?? "electron");
-	const electronPath = electron.default ?? electron;
-	await startup.exit();
-	const stdio = process.platform === "linux" ? [
-		"inherit",
-		"inherit",
-		"inherit",
-		"ignore",
-		"ipc"
-	] : [
-		"inherit",
-		"inherit",
-		"inherit",
-		"ipc"
+function readableSize(size) {
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
 	];
-	process.electronApp = spawn(electronPath, argv, {
-		stdio,
-		...options
-	});
-	process.electronApp.once("exit", process.exit);
-	if (!startup.hookedProcessExit) {
-		startup.hookedProcessExit = true;
-		process.once("exit", startup.exit);
+	let i = 0;
+	while (size >= 1024 && i < units.length - 1) {
+		size /= 1024;
+		i++;
 	}
-};
-startup.send = (message) => {
-	if (process.electronApp) process.electronApp.send?.(message);
-};
-startup.hookedProcessExit = false;
-startup.exit = async () => {
-	if (process.electronApp) await new Promise((resolve) => {
-		process.electronApp.removeAllListeners();
-		process.electronApp.once("exit", resolve);
-		treeKillSync(process.electronApp.pid);
-	});
-};
-
-//#endregion
-//#region src/vite/electron/plugin.ts
-/**
-* @see https://github.com/vitejs/vite/blob/v4.4.7/packages/vite/src/node/utils.ts#L140
-*/
-const bareImportRE = /^(?![a-zA-Z]:)[\w@](?!.*:\/\/)/;
-const nodeModulesRE = /\/node_modules\//;
+	return `${size.toFixed(2)} ${units[i]}`;
+}
 /**
-* During dev, we exclude the `cjs` npm-pkg from bundle, mush like Vite :)
+* Copy file/directory, skipping if target exists
+* @param from - Source path
+* @param to - Destination path
+* @param skipIfExist - Skip copy if destination exists
 */
-function notBundle(options = {}) {
-	const externalIds = /* @__PURE__ */ new Set();
-	return {
-		name: "vite-plugin-electron:not-bundle",
-		enforce: "pre",
-		apply: "serve",
-		resolveId: {
-			filter: { id: bareImportRE },
-			async handler(source, importer) {
-				if (!importer || importer.includes("node_modules/")) return;
-				if (externalIds.has(source)) return {
-					id: source,
-					external: true
-				};
-				const id = (await this.resolve(source, importer, { skipSelf: true }))?.id;
-				if (!id || !nodeModulesRE.test(id) || options.filter?.(id) === false) return;
-				try {
-					createRequire(importer).resolve(source);
-				} catch {
-					return;
-				}
-				externalIds.add(source);
-				return {
-					id: source,
-					external: true,
-					moduleSideEffects: false
-				};
-			}
-		}
-	};
+function copyAndSkipIfExist(from, to, skipIfExist) {
+	if (!skipIfExist || !fs.existsSync(to)) try {
+		fs.cpSync(from, to, { recursive: true });
+	} catch (error) {
+		log.warn(`Copy failed: ${error}`, { timestamp: true });
+	}
 }
-
 //#endregion
-//#region src/utils/crypto.ts
-function hashBuffer(data, length) {
-	const hash = crypto.createHash("SHA256").update(data).digest("binary");
-	return Buffer.from(hash).subarray(0, length);
-}
-function aesEncrypt(plainText, key, iv) {
-	const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
-	return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
-}
+//#region src/vite/utils/build.ts
 /**
-* Default function to generate asar signature, returns generated signature
-* @param buffer file buffer
-* @param privateKey primary key
-* @param cert certificate
-* @param version target version
+* Build asar file and update package
+* @param options - Asar build options
+* @returns Buffer of the built asar file
 */
-function defaultSignature(buffer, privateKey, cert, version) {
-	return aesEncrypt(`${crypto.createSign("RSA-SHA256").update(buffer).sign(crypto.createPrivateKey(privateKey), "base64")}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
+async function buildAsar(root, { version, asarOutputPath, electronDistPath, rendererDistPath, compressedPath, generateCompressedFile }) {
+	electronDistPath = path.resolve(root, electronDistPath);
+	asarOutputPath = path.resolve(root, asarOutputPath);
+	rendererDistPath = path.resolve(root, rendererDistPath);
+	compressedPath = path.resolve(root, compressedPath);
+	const rPath = path.join(electronDistPath, "renderer");
+	await fs.promises.cp(rendererDistPath, rPath, { recursive: true });
+	fs.writeFileSync(path.join(electronDistPath, "version"), version);
+	await fs.promises.mkdir(path.dirname(asarOutputPath), { recursive: true });
+	await createPackage(electronDistPath, asarOutputPath);
+	const buf = await generateCompressedFile(fs.readFileSync(asarOutputPath));
+	await fs.promises.mkdir(path.dirname(compressedPath), { recursive: true });
+	fs.writeFileSync(compressedPath, buf);
+	log.info(`Build update asar to '${compressedPath}' [${readableSize(buf.length)}]`, { timestamp: true });
+	return buf;
 }
-
-//#endregion
-//#region src/utils/zip.ts
 /**
-* Default function to compress file using brotli
-* @param buffer uncompressed file buffer
+* Build update.json file with signature and version information
+* @param options - Version build options
+* @param asarBuffer - Buffer of the asar file to sign
 */
-async function defaultZipFile(buffer) {
-	return new Promise((resolve, reject) => {
-		zlib.brotliCompress(buffer, (err, buffer) => err ? reject(err) : resolve(buffer));
-	});
+async function buildUpdateJson(root, { versionPath, privateKey, cert, version, minimumVersion, generateSignature, generateUpdateJson }, asarBuffer) {
+	const resolvedVersionPath = path.resolve(root, versionPath);
+	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");
+	await fs.promises.mkdir(path.dirname(resolvedVersionPath), { recursive: true });
+	fs.writeFileSync(resolvedVersionPath, JSON.stringify(_json, null, 2));
+	log.info(`Build update json to '${resolvedVersionPath}'`, { timestamp: true });
 }
-
 //#endregion
 //#region src/vite/utils/key.ts
 /**
@@ -708,31 +681,32 @@ function parseSubjects(subject) {
 		value
 	}));
 }
-
 //#endregion
-//#region src/vite/option.ts
-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 = {
+//#region src/vite/core.ts
+async function resolveUpdaterOption(root, pkg, options = {}, resolveSignatureKeys = true) {
+	const { minimumVersion = "0.0.0", paths: { asarOutputPath = `release/${pkg.name}.asar`, compressedPath = `release/${pkg.name}-${pkg.version}.asar.br`, entryOutDir = "dist-entry", electronDistPath = "dist-electron", rendererDistPath = "dist", versionPath = "release/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;
-	const buildAsarOption = {
-		version: pkg.version,
-		asarOutputPath,
-		gzipPath,
-		electronDistPath,
-		rendererDistPath,
-		generateGzipFile
-	};
-	const { privateKey, cert } = await parseKeys({
+	}, days = 3650 } = {} } = {}, overrideGenerator: { generateCompressedFile = defaultCompressFile, generateSignature = defaultSignature, generateUpdateJson = defaultVersionJsonGenerator } = {} } = options;
+	const { privateKey, cert } = resolveSignatureKeys ? await parseKeys({
 		keyLength,
-		privateKeyPath,
-		certPath,
+		privateKeyPath: path.resolve(root, privateKeyPath),
+		certPath: path.resolve(root, certPath),
 		subject,
 		days
-	});
+	}) : {
+		privateKey: "",
+		cert: ""
+	};
 	return {
-		buildAsarOption,
+		buildAsarOption: {
+			version: pkg.version,
+			asarOutputPath,
+			compressedPath,
+			electronDistPath,
+			rendererDistPath,
+			generateCompressedFile
+		},
 		buildVersionOption: {
 			version: pkg.version,
 			minimumVersion,
@@ -742,269 +716,230 @@ async function parseUpdaterOption(pkg, options = {}) {
 			generateSignature,
 			generateUpdateJson
 		},
-		cert,
 		entryOutDir
 	};
 }
-
-//#endregion
-//#region src/vite/utils/build.ts
-/**
-* Build asar file and update package
-* @param options - Asar build options
-* @returns Buffer of the built asar file
-*/
-async function buildAsar({ version, asarOutputPath, gzipPath, electronDistPath, rendererDistPath, generateGzipFile }) {
-	const rPath = path.join(electronDistPath, "renderer");
-	await fs.promises.cp(rendererDistPath, rPath, { recursive: true });
-	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;
-}
-/**
-* Build update.json file with signature and version information
-* @param options - Version build options
-* @param asarBuffer - Buffer of the asar file to sign
-*/
-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
-//#region src/vite/core.ts
-function getMainFileBaseName(options) {
-	let mainFilePath;
-	if (typeof options === "string") mainFilePath = path.basename(options);
-	else if (Array.isArray(options)) mainFilePath = path.basename(options[0]);
-	else {
-		if (!(options?.index ?? options?.main)) throw new Error(`\`options.main.files\` (${options}) must have "index" or "main" key, like \`{ index: "./electron/main/index.ts" }\``);
-		mainFilePath = options?.index ? "index.js" : "main.js";
+function resolveEntryName(files) {
+	if (typeof files === "string") return path.parse(files).name;
+	if (Array.isArray(files)) {
+		const [firstInput] = files;
+		if (!firstInput) throw new Error("`options.main.files` must contain at least one main entry");
+		return path.parse(firstInput).name;
 	}
-	log.info(`Using "${mainFilePath}" as main file`, { timestamp: true });
-	return mainFilePath.replace(/\.[cm]?ts$/, ".js");
+	const firstEntry = Object.entries(files)[0];
+	if (!firstEntry) throw new Error("`options.main.files` must contain at least one main entry");
+	return firstEntry[0];
 }
-function parseVersionPath(versionPath) {
+function normalizeVersionPath(versionPath) {
 	versionPath = normalizePath(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
-* - no `renderer` config
-* - remove old output file
-* - externalize dependencies
-* - auto restart when entry file changes
-* - other configs in {@link https://github.com/electron-vite/electron-vite-vue/blob/main/vite.config.ts electron-vite-vue template}
-*
-* You can override all the vite configs, except output directories (use `options.updater.paths.electronDistPath` instead)
-*
-* @example
-* ```ts
-* import { defineConfig } from 'vite'
-* import { debugStartup, electronWithUpdater } from 'electron-incremental-update/vite'
-*
-* export default defineConfig(async ({ command }) => {
-*   const isBuild = command === 'build'
-*   return {
-*     plugins: [
-*       electronWithUpdater({
-*         isBuild,
-*         main: {
-*           files: ['./electron/main/index.ts', './electron/main/worker.ts'],
-*           // see https://github.com/electron-vite/electron-vite-vue/blob/85ed267c4851bf59f32888d766c0071661d4b94c/vite.config.ts#L22-L28
-*           onstart: debugStartup,
-*         },
-*         preload: {
-*           files: './electron/preload/index.ts',
-*         },
-*         updater: {
-*           // options
-*         }
-*       }),
-*     ],
-*     server: process.env.VSCODE_DEBUG && (() => {
-*       const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)
-*       return {
-*         host: url.hostname,
-*         port: +url.port,
-*       }
-*     })(),
-*   }
-* })
-* ```
-*/
-async function electronWithUpdater(options) {
-	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);
+async function createElectronOptions(options, context) {
+	const { entry, main, preload, sourcemap = context.isDev || !!process.env.VSCODE_DEBUG, minify = !context.isDev, buildVersionJson, notBundle = true, external, updater, bytecode, localDevUpdate } = options;
+	const pkg = context.packageJson;
 	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;
+	const finalExternal = [...defaultExternal];
+	if (external === true) finalExternal.push(...Object.keys(pkg.dependencies || {}));
+	else if (Array.isArray(external)) finalExternal.push(...external);
+	const bytecodeOptions = typeof bytecode === "object" ? {
+		...bytecode,
+		enable: bytecode.enable ?? true
+	} : 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, buildVersionOption, cert, entryOutDir } = await parseUpdaterOption(pkg, updater);
+	const resolvedLocalDevUpdate = context.isDev ? resolveLocalDevUpdateOptions(context.root, localDevUpdate) : void 0;
+	const updatePkg = await resolveLocalDevUpdatePackage(pkg, resolvedLocalDevUpdate);
+	const { buildAsarOption, buildVersionOption, entryOutDir } = await resolveUpdaterOption(context.root, updatePkg, updater, !resolvedLocalDevUpdate);
+	const mainFileName = `${resolveEntryName(main.files)}.${isESM ? "mjs" : "js"}`;
+	log.info(`Using "${mainFileName}" as main file`, { timestamp: true });
 	log.info(`Clear cache files`, { timestamp: true });
 	await Promise.all([
-		fs.promises.rm(buildAsarOption.rendererDistPath, {
-			recursive: true,
-			force: true
-		}),
-		fs.promises.rm(buildAsarOption.electronDistPath, {
-			recursive: true,
-			force: true
-		}),
-		fs.promises.rm(entryOutDir, {
-			recursive: true,
-			force: true
-		})
-	]).catch(() => {});
+		buildAsarOption.rendererDistPath,
+		buildAsarOption.electronDistPath,
+		entryOutDir
+	].map((p) => fs.promises.rm(path.resolve(context.root, p), {
+		recursive: true,
+		force: true
+	}))).catch(() => {});
+	const outputNames = {
+		entryFileNames: `[name].${isESM ? "mjs" : "js"}`,
+		chunkFileNames: `[name].${isESM ? "mjs" : "js"}`,
+		assetFileNames: "[name].[ext]"
+	};
+	const versionPath = normalizeVersionPath(normalizePath(buildVersionOption.versionPath));
+	const mainOnstart = resolvedLocalDevUpdate ? createLocalDevUpdateOnstart({
+		root: context.root,
+		pkg: updatePkg,
+		buildAsarOption,
+		versionPath,
+		minimumVersion: buildVersionOption.minimumVersion,
+		localDevUpdate: resolvedLocalDevUpdate,
+		userOnstart: main.onstart
+	}) : main.onstart;
 	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(entryOutDir)),
-		__EIU_IS_DEV__: JSON.stringify(!isBuild),
+		__EIU_IS_DEV__: JSON.stringify(context.isDev),
 		__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)))
+		__EIU_LOCAL_DEV_UPDATE__: JSON.stringify(!!resolvedLocalDevUpdate),
+		__EIU_LOCAL_DEV_UPDATE_ASAR_PATH__: JSON.stringify(resolvedLocalDevUpdate?.installedAsarPath ?? ""),
+		__EIU_LOCAL_DEV_UPDATE_CHUNK_DELAY__: JSON.stringify(resolvedLocalDevUpdate?.chunkDelay) ?? "undefined",
+		__EIU_LOCAL_DEV_UPDATE_CHUNK_SIZE__: JSON.stringify(resolvedLocalDevUpdate?.chunkSize) ?? "undefined",
+		__EIU_LOCAL_DEV_UPDATE_DIR__: JSON.stringify(resolvedLocalDevUpdate?.baseDir ?? ""),
+		__EIU_MAIN_FILE__: JSON.stringify(mainFileName),
+		__EIU_SIGNATURE_CERT__: JSON.stringify(buildVersionOption.cert),
+		__EIU_VERSION_PATH__: JSON.stringify(versionPath)
 	};
 	const _electronOptions = [{
-		entry: _main.files,
-		onstart: _main.onstart,
-		vite: mergeConfig({
-			plugins: [!isBuild && useNotBundle && notBundle(), bytecodeOptions && bytecodePlugin("main", isESM, bytecodeOptions)],
+		name: "main",
+		input: main.files,
+		onstart: mainOnstart,
+		notBundle,
+		plugins: [isESM && esmShim(), bytecodeOptions && bytecodePlugin("main", minify, isESM, bytecodeOptions)],
+		options: mergeConfig({
 			build: {
 				sourcemap,
 				minify,
 				outDir: `${buildAsarOption.electronDistPath}/main`,
 				rolldownOptions: {
 					external: finalExternal,
-					platform: "node",
 					output: {
-						polyfillRequire: false,
-						exports: "named"
+						format: isESM ? "es" : "cjs",
+						polyfillRequire: isESM,
+						...outputNames
 					}
 				}
 			},
 			define
-		}, _main.vite ?? {})
+		}, main.options ?? {})
 	}];
-	if (_preload?.files) _electronOptions.push({
+	if (preload?.files) _electronOptions.push({
+		name: "preload",
 		onstart(args) {
 			args.reload();
 		},
-		vite: mergeConfig({
-			plugins: [bytecodeOptions && bytecodePlugin("preload", isESM, bytecodeOptions)],
+		notBundle,
+		input: preload.files,
+		plugins: [isESM && esmShim(), bytecodeOptions && bytecodePlugin("preload", minify, isESM, bytecodeOptions)],
+		options: mergeConfig({
 			build: {
 				sourcemap: sourcemap ? "inline" : void 0,
 				minify,
 				outDir: `${buildAsarOption.electronDistPath}/preload`,
 				rolldownOptions: {
 					external: finalExternal,
-					input: _preload.files,
 					output: {
 						format: "cjs",
 						codeSplitting: false,
 						polyfillRequire: false,
-						entryFileNames: `[name].${isESM ? "mjs" : "js"}`,
-						chunkFileNames: `[name].${isESM ? "mjs" : "js"}`,
-						assetFileNames: "[name].[ext]"
+						...outputNames
 					}
 				}
 			},
 			define
-		}, _preload?.vite ?? {})
+		}, preload?.options ?? {})
 	});
 	_electronOptions.push({
-		entry: _entry.files,
-		vite: mergeConfig({
-			plugins: [
-				bytecodeOptions && bytecodePlugin("main", isESM, bytecodeOptions),
-				!isBuild && useNotBundle && notBundle(),
-				{
-					name: `${id}:entry`,
-					enforce: "post",
-					async closeBundle() {
-						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);
-								}
+		name: "entry",
+		input: entry.files,
+		async onstart(args) {
+			if (mainOnstart) await mainOnstart(args);
+			else await args.startup();
+		},
+		notBundle,
+		plugins: [
+			isESM && esmShim(),
+			bytecodeOptions && bytecodePlugin("entry", minify, isESM, bytecodeOptions),
+			{
+				name: `${id}:entry`,
+				async closeBundle() {
+					log.info(`Build entry to '${entryOutDir}'`, { timestamp: true });
+					await entry.postBuild?.({
+						isBuild: !context.isDev,
+						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;
 							}
-						});
-						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);
+							copyAndSkipIfExist(from, path.join(entryOutDir, to), skipIfExist);
+						},
+						copyModules() {
+							console.warn("`copyModules()` is deprecated. Will do nothing");
 						}
-					}
+					});
+					if (context.isDev) return;
+					const buffer = await buildAsar(context.root, 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(context.root, buildVersionOption, buffer);
 				}
-			],
+			}
+		],
+		options: mergeConfig({
 			build: {
 				sourcemap,
 				minify,
 				outDir: entryOutDir,
 				rolldownOptions: {
 					external: finalExternal,
-					platform: "node",
-					output: { polyfillRequire: false }
+					output: {
+						format: isESM ? "es" : "cjs",
+						polyfillRequire: isESM,
+						...outputNames
+					}
 				}
 			},
 			define
-		}, _entry.vite || {})
+		}, entry.options || {})
+	});
+	return _electronOptions;
+}
+/**
+* Base on `vite-plugin-electron/multi-env`
+* - integrate with updater
+* - no `renderer` config
+* - remove old output file
+* - externalize dependencies
+* - auto restart when entry file changes
+*
+* You can override all the environment configs, except output directories (use `options.updater.paths.electronDistPath` instead)
+*
+* @example
+* ```ts
+* import { defineConfig } from 'vite'
+* import { electronWithUpdater } from 'electron-incremental-update/vite'
+*
+* export default defineConfig(async ({ command }) => {
+*   const isBuild = command === 'build'
+*   return {
+*     plugins: [
+*       electronWithUpdater({
+*         isBuild,
+*         main: {
+*           files: ['./electron/main/index.ts', './electron/main/worker.ts'],
+*         },
+*         preload: {
+*           files: './electron/preload/index.ts',
+*         },
+*         updater: {
+*           // options
+*         }
+*       }),
+*     ],
+*   }
+* })
+* ```
+*/
+async function electronWithUpdater(options) {
+	return electronPluginFactory((context) => {
+		process.CACHED_ELECTRON_OPTIONS ??= createElectronOptions(options, context);
+		return process.CACHED_ELECTRON_OPTIONS;
 	});
-	return electron(isESM, normalizePath(path.resolve(root)), _electronOptions);
 }
-
 //#endregion
 //#region src/vite/define.ts
 /**
@@ -1015,10 +950,9 @@ async function electronWithUpdater(options) {
 * import { defineElectronConfig } from 'electron-incremental-update/vite'
 *
 * export default defineElectronConfig({
+*   // root: './apps'
 *   main: {
 *     files: ['./electron/main/index.ts', './electron/main/worker.ts'],
-*     // see https://github.com/electron-vite/electron-vite-vue/blob/85ed267c4851bf59f32888d766c0071661d4b94c/vite.config.ts#L22-L28
-*     onstart: debugStartup,
 *   },
 *   preload: {
 *     files: './electron/preload/index.ts',
@@ -1027,33 +961,23 @@ async function electronWithUpdater(options) {
 *     // options
 *   },
 *   renderer: {
-*     server: process.env.VSCODE_DEBUG && (() => {
-*       const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)
-*       return {
-*         host: url.hostname,
-*         port: +url.port,
-*       }
-*     })(),
+*     // plugins: []
 *   }
 * })
 * ```
 */
 function defineElectronConfig(options) {
-	return ({ command }) => {
-		options.isBuild ??= command === "build";
-		const electronPlugin = electronWithUpdater(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 ??= {};
-			result.build.outDir = rendererDistPath;
-		}
-		return result;
-	};
+	const electronPlugin = electronWithUpdater(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 ??= {};
+		result.build.outDir = rendererDistPath;
+	}
+	return result;
 }
-
 //#endregion
-export { debugStartup, electronWithUpdater as default, electronWithUpdater, defineElectronConfig, filterErrorMessageStartup, fixWinCharEncoding };
+export { electronWithUpdater as default, electronWithUpdater, defineElectronConfig, filterErrorMessageStartup, fixWinCharEncoding };