npm - @cordy/electro-cli - Versions diffs - 1.0.0 - Mend

@cordy/electro-cli 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,3362 @@
+#!/usr/bin/env bun
+import { builtinModules } from "node:module";
+import { EventEmitter } from "events";
+import { access, mkdir, readFile, rm, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { generate, scan } from "@cordy/electro-generator";
+import { build, createLogger, createServer, mergeConfig, version } from "vite";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { spawn } from "node:child_process";
+//#region ../../node_modules/.bun/cac@6.7.14/node_modules/cac/dist/index.mjs
+function toArr(any) {
+	return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+	var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+	out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function mri2(args, opts) {
+	args = args || [];
+	opts = opts || {};
+	var k, arr, arg, name, val, out = { _: [] };
+	var i = 0, j = 0, idx = 0, len = args.length;
+	const alibi = opts.alias !== void 0;
+	const strict = opts.unknown !== void 0;
+	const defaults = opts.default !== void 0;
+	opts.alias = opts.alias || {};
+	opts.string = toArr(opts.string);
+	opts.boolean = toArr(opts.boolean);
+	if (alibi) for (k in opts.alias) {
+		arr = opts.alias[k] = toArr(opts.alias[k]);
+		for (i = 0; i < arr.length; i++) (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+	}
+	for (i = opts.boolean.length; i-- > 0;) {
+		arr = opts.alias[opts.boolean[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.boolean.push(arr[j]);
+	}
+	for (i = opts.string.length; i-- > 0;) {
+		arr = opts.alias[opts.string[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.string.push(arr[j]);
+	}
+	if (defaults) for (k in opts.default) {
+		name = typeof opts.default[k];
+		arr = opts.alias[k] = opts.alias[k] || [];
+		if (opts[name] !== void 0) {
+			opts[name].push(k);
+			for (i = 0; i < arr.length; i++) opts[name].push(arr[i]);
+		}
+	}
+	const keys = strict ? Object.keys(opts.alias) : [];
+	for (i = 0; i < len; i++) {
+		arg = args[i];
+		if (arg === "--") {
+			out._ = out._.concat(args.slice(++i));
+			break;
+		}
+		for (j = 0; j < arg.length; j++) if (arg.charCodeAt(j) !== 45) break;
+		if (j === 0) out._.push(arg);
+		else if (arg.substring(j, j + 3) === "no-") {
+			name = arg.substring(j + 3);
+			if (strict && !~keys.indexOf(name)) return opts.unknown(arg);
+			out[name] = false;
+		} else {
+			for (idx = j + 1; idx < arg.length; idx++) if (arg.charCodeAt(idx) === 61) break;
+			name = arg.substring(j, idx);
+			val = arg.substring(++idx) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
+			arr = j === 2 ? [name] : name;
+			for (idx = 0; idx < arr.length; idx++) {
+				name = arr[idx];
+				if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+				toVal(out, name, idx + 1 < arr.length || val, opts);
+			}
+		}
+	}
+	if (defaults) {
+		for (k in opts.default) if (out[k] === void 0) out[k] = opts.default[k];
+	}
+	if (alibi) for (k in out) {
+		arr = opts.alias[k] || [];
+		while (arr.length > 0) out[arr.shift()] = out[k];
+	}
+	return out;
+}
+const removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
+const findAllBrackets = (v) => {
+	const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+	const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+	const res = [];
+	const parse = (match) => {
+		let variadic = false;
+		let value = match[1];
+		if (value.startsWith("...")) {
+			value = value.slice(3);
+			variadic = true;
+		}
+		return {
+			required: match[0].startsWith("<"),
+			value,
+			variadic
+		};
+	};
+	let angledMatch;
+	while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) res.push(parse(angledMatch));
+	let squareMatch;
+	while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) res.push(parse(squareMatch));
+	return res;
+};
+const getMriOptions = (options) => {
+	const result = {
+		alias: {},
+		boolean: []
+	};
+	for (const [index, option] of options.entries()) {
+		if (option.names.length > 1) result.alias[option.names[0]] = option.names.slice(1);
+		if (option.isBoolean) if (option.negated) {
+			if (!options.some((o, i) => {
+				return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+			})) result.boolean.push(option.names[0]);
+		} else result.boolean.push(option.names[0]);
+	}
+	return result;
+};
+const findLongest = (arr) => {
+	return arr.sort((a, b) => {
+		return a.length > b.length ? -1 : 1;
+	})[0];
+};
+const padRight = (str, length) => {
+	return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+};
+const camelcase = (input) => {
+	return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+		return p1 + p2.toUpperCase();
+	});
+};
+const setDotProp = (obj, keys, val) => {
+	let i = 0;
+	let length = keys.length;
+	let t = obj;
+	let x;
+	for (; i < length; ++i) {
+		x = t[keys[i]];
+		t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+	}
+};
+const setByType = (obj, transforms) => {
+	for (const key of Object.keys(transforms)) {
+		const transform = transforms[key];
+		if (transform.shouldTransform) {
+			obj[key] = Array.prototype.concat.call([], obj[key]);
+			if (typeof transform.transformFunction === "function") obj[key] = obj[key].map(transform.transformFunction);
+		}
+	}
+};
+const getFileName = (input) => {
+	const m = /([^\\\/]+)$/.exec(input);
+	return m ? m[1] : "";
+};
+const camelcaseOptionName = (name) => {
+	return name.split(".").map((v, i) => {
+		return i === 0 ? camelcase(v) : v;
+	}).join(".");
+};
+var CACError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+		if (typeof Error.captureStackTrace === "function") Error.captureStackTrace(this, this.constructor);
+		else this.stack = new Error(message).stack;
+	}
+};
+var Option = class {
+	constructor(rawName, description, config) {
+		this.rawName = rawName;
+		this.description = description;
+		this.config = Object.assign({}, config);
+		rawName = rawName.replace(/\.\*/g, "");
+		this.negated = false;
+		this.names = removeBrackets(rawName).split(",").map((v) => {
+			let name = v.trim().replace(/^-{1,2}/, "");
+			if (name.startsWith("no-")) {
+				this.negated = true;
+				name = name.replace(/^no-/, "");
+			}
+			return camelcaseOptionName(name);
+		}).sort((a, b) => a.length > b.length ? 1 : -1);
+		this.name = this.names[this.names.length - 1];
+		if (this.negated && this.config.default == null) this.config.default = true;
+		if (rawName.includes("<")) this.required = true;
+		else if (rawName.includes("[")) this.required = false;
+		else this.isBoolean = true;
+	}
+};
+const processArgs = process.argv;
+const platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
+var Command = class {
+	constructor(rawName, description, config = {}, cli) {
+		this.rawName = rawName;
+		this.description = description;
+		this.config = config;
+		this.cli = cli;
+		this.options = [];
+		this.aliasNames = [];
+		this.name = removeBrackets(rawName);
+		this.args = findAllBrackets(rawName);
+		this.examples = [];
+	}
+	usage(text) {
+		this.usageText = text;
+		return this;
+	}
+	allowUnknownOptions() {
+		this.config.allowUnknownOptions = true;
+		return this;
+	}
+	ignoreOptionDefaultValue() {
+		this.config.ignoreOptionDefaultValue = true;
+		return this;
+	}
+	version(version, customFlags = "-v, --version") {
+		this.versionNumber = version;
+		this.option(customFlags, "Display version number");
+		return this;
+	}
+	example(example) {
+		this.examples.push(example);
+		return this;
+	}
+	option(rawName, description, config) {
+		const option = new Option(rawName, description, config);
+		this.options.push(option);
+		return this;
+	}
+	alias(name) {
+		this.aliasNames.push(name);
+		return this;
+	}
+	action(callback) {
+		this.commandAction = callback;
+		return this;
+	}
+	isMatched(name) {
+		return this.name === name || this.aliasNames.includes(name);
+	}
+	get isDefaultCommand() {
+		return this.name === "" || this.aliasNames.includes("!");
+	}
+	get isGlobalCommand() {
+		return this instanceof GlobalCommand;
+	}
+	hasOption(name) {
+		name = name.split(".")[0];
+		return this.options.find((option) => {
+			return option.names.includes(name);
+		});
+	}
+	outputHelp() {
+		const { name, commands } = this.cli;
+		const { versionNumber, options: globalOptions, helpCallback } = this.cli.globalCommand;
+		let sections = [{ body: `${name}${versionNumber ? `/${versionNumber}` : ""}` }];
+		sections.push({
+			title: "Usage",
+			body: `  $ ${name} ${this.usageText || this.rawName}`
+		});
+		if ((this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0) {
+			const longestCommandName = findLongest(commands.map((command) => command.rawName));
+			sections.push({
+				title: "Commands",
+				body: commands.map((command) => {
+					return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+				}).join("\n")
+			});
+			sections.push({
+				title: `For more info, run any command with the \`--help\` flag`,
+				body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+			});
+		}
+		let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+		if (!this.isGlobalCommand && !this.isDefaultCommand) options = options.filter((option) => option.name !== "version");
+		if (options.length > 0) {
+			const longestOptionName = findLongest(options.map((option) => option.rawName));
+			sections.push({
+				title: "Options",
+				body: options.map((option) => {
+					return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+				}).join("\n")
+			});
+		}
+		if (this.examples.length > 0) sections.push({
+			title: "Examples",
+			body: this.examples.map((example) => {
+				if (typeof example === "function") return example(name);
+				return example;
+			}).join("\n")
+		});
+		if (helpCallback) sections = helpCallback(sections) || sections;
+		console.log(sections.map((section) => {
+			return section.title ? `${section.title}:
+${section.body}` : section.body;
+		}).join("\n\n"));
+	}
+	outputVersion() {
+		const { name } = this.cli;
+		const { versionNumber } = this.cli.globalCommand;
+		if (versionNumber) console.log(`${name}/${versionNumber} ${platformInfo}`);
+	}
+	checkRequiredArgs() {
+		const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+		if (this.cli.args.length < minimalArgsCount) throw new CACError(`missing required args for command \`${this.rawName}\``);
+	}
+	checkUnknownOptions() {
+		const { options, globalCommand } = this.cli;
+		if (!this.config.allowUnknownOptions) {
+			for (const name of Object.keys(options)) if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+		}
+	}
+	checkOptionValue() {
+		const { options: parsedOptions, globalCommand } = this.cli;
+		const options = [...globalCommand.options, ...this.options];
+		for (const option of options) {
+			const value = parsedOptions[option.name.split(".")[0]];
+			if (option.required) {
+				const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+				if (value === true || value === false && !hasNegated) throw new CACError(`option \`${option.rawName}\` value is missing`);
+			}
+		}
+	}
+};
+var GlobalCommand = class extends Command {
+	constructor(cli) {
+		super("@@global@@", "", {}, cli);
+	}
+};
+var __assign = Object.assign;
+var CAC = class extends EventEmitter {
+	constructor(name = "") {
+		super();
+		this.name = name;
+		this.commands = [];
+		this.rawArgs = [];
+		this.args = [];
+		this.options = {};
+		this.globalCommand = new GlobalCommand(this);
+		this.globalCommand.usage("<command> [options]");
+	}
+	usage(text) {
+		this.globalCommand.usage(text);
+		return this;
+	}
+	command(rawName, description, config) {
+		const command = new Command(rawName, description || "", config, this);
+		command.globalCommand = this.globalCommand;
+		this.commands.push(command);
+		return command;
+	}
+	option(rawName, description, config) {
+		this.globalCommand.option(rawName, description, config);
+		return this;
+	}
+	help(callback) {
+		this.globalCommand.option("-h, --help", "Display this message");
+		this.globalCommand.helpCallback = callback;
+		this.showHelpOnExit = true;
+		return this;
+	}
+	version(version, customFlags = "-v, --version") {
+		this.globalCommand.version(version, customFlags);
+		this.showVersionOnExit = true;
+		return this;
+	}
+	example(example) {
+		this.globalCommand.example(example);
+		return this;
+	}
+	outputHelp() {
+		if (this.matchedCommand) this.matchedCommand.outputHelp();
+		else this.globalCommand.outputHelp();
+	}
+	outputVersion() {
+		this.globalCommand.outputVersion();
+	}
+	setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+		this.args = args;
+		this.options = options;
+		if (matchedCommand) this.matchedCommand = matchedCommand;
+		if (matchedCommandName) this.matchedCommandName = matchedCommandName;
+		return this;
+	}
+	unsetMatchedCommand() {
+		this.matchedCommand = void 0;
+		this.matchedCommandName = void 0;
+	}
+	parse(argv = processArgs, { run = true } = {}) {
+		this.rawArgs = argv;
+		if (!this.name) this.name = argv[1] ? getFileName(argv[1]) : "cli";
+		let shouldParse = true;
+		for (const command of this.commands) {
+			const parsed = this.mri(argv.slice(2), command);
+			const commandName = parsed.args[0];
+			if (command.isMatched(commandName)) {
+				shouldParse = false;
+				const parsedInfo = __assign(__assign({}, parsed), { args: parsed.args.slice(1) });
+				this.setParsedInfo(parsedInfo, command, commandName);
+				this.emit(`command:${commandName}`, command);
+			}
+		}
+		if (shouldParse) {
+			for (const command of this.commands) if (command.name === "") {
+				shouldParse = false;
+				const parsed = this.mri(argv.slice(2), command);
+				this.setParsedInfo(parsed, command);
+				this.emit(`command:!`, command);
+			}
+		}
+		if (shouldParse) {
+			const parsed = this.mri(argv.slice(2));
+			this.setParsedInfo(parsed);
+		}
+		if (this.options.help && this.showHelpOnExit) {
+			this.outputHelp();
+			run = false;
+			this.unsetMatchedCommand();
+		}
+		if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+			this.outputVersion();
+			run = false;
+			this.unsetMatchedCommand();
+		}
+		const parsedArgv = {
+			args: this.args,
+			options: this.options
+		};
+		if (run) this.runMatchedCommand();
+		if (!this.matchedCommand && this.args[0]) this.emit("command:*");
+		return parsedArgv;
+	}
+	mri(argv, command) {
+		const cliOptions = [...this.globalCommand.options, ...command ? command.options : []];
+		const mriOptions = getMriOptions(cliOptions);
+		let argsAfterDoubleDashes = [];
+		const doubleDashesIndex = argv.indexOf("--");
+		if (doubleDashesIndex > -1) {
+			argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+			argv = argv.slice(0, doubleDashesIndex);
+		}
+		let parsed = mri2(argv, mriOptions);
+		parsed = Object.keys(parsed).reduce((res, name) => {
+			return __assign(__assign({}, res), { [camelcaseOptionName(name)]: parsed[name] });
+		}, { _: [] });
+		const args = parsed._;
+		const options = { "--": argsAfterDoubleDashes };
+		const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+		let transforms = Object.create(null);
+		for (const cliOption of cliOptions) {
+			if (!ignoreDefault && cliOption.config.default !== void 0) for (const name of cliOption.names) options[name] = cliOption.config.default;
+			if (Array.isArray(cliOption.config.type)) {
+				if (transforms[cliOption.name] === void 0) {
+					transforms[cliOption.name] = Object.create(null);
+					transforms[cliOption.name]["shouldTransform"] = true;
+					transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
+				}
+			}
+		}
+		for (const key of Object.keys(parsed)) if (key !== "_") {
+			setDotProp(options, key.split("."), parsed[key]);
+			setByType(options, transforms);
+		}
+		return {
+			args,
+			options
+		};
+	}
+	runMatchedCommand() {
+		const { args, options, matchedCommand: command } = this;
+		if (!command || !command.commandAction) return;
+		command.checkUnknownOptions();
+		command.checkOptionValue();
+		command.checkRequiredArgs();
+		const actionArgs = [];
+		command.args.forEach((arg, index) => {
+			if (arg.variadic) actionArgs.push(args.slice(index));
+			else actionArgs.push(args[index]);
+		});
+		actionArgs.push(options);
+		return command.commandAction.apply(this, actionArgs);
+	}
+};
+const cac = (name = "") => new CAC(name);
+//#endregion
+//#region package.json
+var version$1 = "1.0.0";
+//#endregion
+//#region src/dev/logger.ts
+const yellow$1 = "\x1B[33m";
+const green = "\x1B[32m";
+const cyan = "\x1B[36m";
+const red$1 = "\x1B[31m";
+const magenta = "\x1B[35m";
+const dim$1 = "\x1B[90m";
+const bold = "\x1B[1m";
+const reset$1 = "\x1B[0m";
+const levels = {
+	info: 0,
+	warn: 1,
+	error: 2,
+	silent: 3
+};
+let currentLevel = "info";
+function setLogLevel(level) {
+	currentLevel = level;
+}
+function info(msg) {
+	if (levels[currentLevel] > levels.info) return;
+	console.log(`  ${dim$1}▸${reset$1} ${msg}`);
+}
+function warn(msg) {
+	if (levels[currentLevel] > levels.warn) return;
+	console.log(`  ${yellow$1}⚠ ${msg}${reset$1}`);
+}
+function error(msg) {
+	if (levels[currentLevel] > levels.error) return;
+	console.error(`  ${red$1}✗ ${msg}${reset$1}`);
+}
+function note(msg) {
+	if (levels[currentLevel] > levels.info) return;
+	console.log(`    ${dim$1}${msg}${reset$1}`);
+}
+function startTimer() {
+	const startedAt = Date.now();
+	return () => formatDuration(Date.now() - startedAt);
+}
+function formatDuration(ms) {
+	if (ms < 1e3) return `${ms}ms`;
+	const seconds = ms / 1e3;
+	if (seconds < 60) return `${seconds.toFixed(1)}s`;
+	return `${Math.floor(seconds / 60)}m${Math.round(seconds % 60).toString().padStart(2, "0")}s`;
+}
+const STEP_WIDTH = 26;
+function step(label, duration, extra) {
+	if (levels[currentLevel] > levels.info) return;
+	const dotsLen = Math.max(2, STEP_WIDTH - label.length - 1);
+	const dots = "·".repeat(dotsLen);
+	const dur = duration.padStart(5);
+	const suffix = extra ? `  ${dim$1}${extra}${reset$1}` : "";
+	console.log(`  ${label} ${dim$1}${dots}${reset$1} ${green}✓${reset$1} ${green}${dur}${reset$1}${suffix}`);
+}
+function stepFail(label, message) {
+	const dotsLen = Math.max(2, STEP_WIDTH - label.length - 1);
+	const dots = "·".repeat(dotsLen);
+	console.error(`  ${label} ${dim$1}${dots}${reset$1} ${red$1}✗ ${message}${reset$1}`);
+}
+function colorRuntimeMessage(msg) {
+	if (msg.startsWith("hmr update")) return `${green}${msg}${reset$1}`;
+	if (msg.startsWith("page reload")) return `${yellow$1}page reload${reset$1}${msg.slice(11)}`;
+	if (msg.startsWith("rebuild")) return `${cyan}rebuild${reset$1}${msg.slice(7)}`;
+	if (msg.startsWith("generated")) return `${magenta}generated${reset$1}`;
+	if (msg.startsWith("crashed")) return `${red$1}${msg}${reset$1}`;
+	if (msg.startsWith("exited")) return `${dim$1}exited${reset$1}`;
+	return msg;
+}
+function formatTime(d) {
+	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}
+function clearProgressLine() {
+	if (process.stdout.isTTY) {
+		process.stdout.clearLine(0);
+		process.stdout.cursorTo(0);
+	}
+}
+function runtimeLog(scope, msg, changedFile) {
+	if (levels[currentLevel] > levels.info) return;
+	clearProgressLine();
+	const time = formatTime(/* @__PURE__ */ new Date());
+	const filePart = changedFile ? ` ${dim$1}${changedFile}${reset$1}` : "";
+	console.log(`${dim$1}${time}${reset$1} ${yellow$1}[electro]${reset$1} ${dim$1}(${scope})${reset$1} ${colorRuntimeMessage(msg)}${filePart}`);
+}
+function footer(message, url) {
+	if (levels[currentLevel] > levels.info) return;
+	console.log(`\n  ${bold}${green}✓ ${message}${reset$1}`);
+	if (url) console.log(`    ${yellow$1}→ ${url}${reset$1}`);
+	console.log("");
+}
+function toProjectRelative(root, absolutePath) {
+	return relative(root, absolutePath) || ".";
+}
+function session(meta) {
+	if (levels[currentLevel] > levels.info) return;
+	const isBuild = meta.mode === "build";
+	const projectName = basename(meta.root);
+	const mainEntry = toProjectRelative(meta.root, meta.main);
+	const preloadEntry = meta.preload ? toProjectRelative(meta.root, meta.preload) : `${dim$1}(none)${reset$1}`;
+	const rendererEntry = meta.renderer ? toProjectRelative(meta.root, meta.renderer) : `${dim$1}(none)${reset$1}`;
+	const command = isBuild ? "build" : "dev";
+	console.log(`\n${bold}${yellow$1}⚡ electro ${command}${reset$1} → ${cyan}${projectName}${reset$1}\n`);
+	const mainMode = isBuild ? "build" : "watch";
+	const preloadMode = isBuild ? "build" : "watch";
+	const rendererMode = isBuild ? "build" : "dev server";
+	const entryWidth = Math.max(14, mainEntry.length, preloadEntry.length, rendererEntry.length) + 2;
+	console.log(`  ${dim$1}Scope      ${"Entry".padEnd(entryWidth)}Mode${reset$1}`);
+	console.log(`  ${cyan}main${reset$1}       ${mainEntry.padEnd(entryWidth)}${dim$1}${mainMode}${reset$1}`);
+	console.log(`  ${yellow$1}preload${reset$1}    ${preloadEntry.padEnd(entryWidth)}${dim$1}${preloadMode}${reset$1}`);
+	console.log(`  ${green}renderer${reset$1}   ${rendererEntry.padEnd(entryWidth)}${dim$1}${rendererMode}${reset$1}`);
+	if (meta.windows && meta.windows.length > 0) {
+		console.log("");
+		console.log(`  ${dim$1}Windows${reset$1}    ${meta.windows.length} configured`);
+		for (const win of meta.windows) {
+			const winEntry = toProjectRelative(meta.root, win.entry);
+			console.log(`  ${win.name.padEnd(10)} ${dim$1}${winEntry}${reset$1}`);
+		}
+	}
+	console.log("");
+}
+const ANSI_RE = new RegExp(String.raw`\x1b\[[0-9;]*m`, "g");
+const VITE_TAG_RE = new RegExp(String.raw`(?:\x1b\[[0-9;]*m)*\[(vite(?:-plugin-[^\]]+)?)\](?:\x1b\[[0-9;]*m)*`, "g");
+function retagMessage(msg) {
+	return msg.replace(VITE_TAG_RE, `[${bold}${yellow$1}electro${reset$1}]`);
+}
+/**
+* Patch a Vite logger to rebrand `[vite]` → `[electro]`,
+* suppress startup noise ("ready in", "➜"), and extract
+* HMR/reload targets for cleaner output.
+*/
+function patchLogger(logger, scope) {
+	const origInfo = logger.info.bind(logger);
+	logger.info = (msg, options) => {
+		if (typeof msg !== "string") return origInfo(msg, options);
+		const clean = msg.replace(ANSI_RE, "").trim();
+		if (!clean || clean.includes("ready in") || clean.includes("➜")) return;
+		if (clean.includes("hmr update")) {
+			const target = extractTarget(clean, "hmr update");
+			runtimeLog(scope, `hmr update${target ? ` ${target}` : ""}`);
+			return;
+		}
+		if (clean.includes("hmr invalidate")) {
+			const target = extractTarget(clean, "hmr invalidate");
+			runtimeLog(scope, `hmr invalidate${target ? ` ${target}` : ""}`);
+			return;
+		}
+		if (clean.includes("page reload")) {
+			const target = extractTarget(clean, "page reload");
+			runtimeLog(scope, `page reload${target ? ` ${target}` : ""}`);
+			return;
+		}
+		origInfo(retagMessage(msg), options);
+	};
+	const origWarn = logger.warn.bind(logger);
+	logger.warn = (msg, options) => {
+		if (typeof msg !== "string") return origWarn(msg, options);
+		origWarn(retagMessage(msg), options);
+	};
+	const origError = logger.error.bind(logger);
+	logger.error = (msg, options) => {
+		if (typeof msg !== "string") return origError(msg, options);
+		origError(retagMessage(msg), options);
+	};
+}
+function extractTarget(message, event) {
+	return message.match(new RegExp(`\\b${event}\\b\\s+(.+)$`))?.[1]?.trim() ?? null;
+}
+/** Print a scope header before a production build step. */
+function buildScope(scope) {
+	if (levels[currentLevel] > levels.info) return;
+	const color = scope === "main" ? cyan : scope === "preload" ? yellow$1 : green;
+	console.log(`\n  ${color}${scope}${reset$1}`);
+}
+/**
+* Create a Vite Logger for production builds.
+* Suppresses the "vite vX building..." header (we print our own banner)
+* and rebrands `[vite]` → `[electro]`. Everything else — transforming
+* progress, file listing with sizes, "built in" — passes through.
+*/
+function createBuildLogger() {
+	const logger = createLogger(currentLevel, { allowClearScreen: false });
+	const origInfo = logger.info.bind(logger);
+	logger.info = (msg, options) => {
+		if (typeof msg !== "string") return origInfo(msg, options);
+		const clean = msg.replace(ANSI_RE, "").trim();
+		if (/^vite v[\d.]+/.test(clean) && clean.includes("building")) return;
+		if (!clean) return;
+		origInfo(retagMessage(msg), options);
+	};
+	const origWarn = logger.warn.bind(logger);
+	logger.warn = (msg, options) => {
+		if (typeof msg !== "string") return origWarn(msg, options);
+		origWarn(retagMessage(msg), options);
+	};
+	const origError = logger.error.bind(logger);
+	logger.error = (msg, options) => {
+		if (typeof msg !== "string") return origError(msg, options);
+		origError(retagMessage(msg), options);
+	};
+	return logger;
+}
+//#endregion
+//#region src/validate.ts
+const VALID_SOURCEMAP_VALUES = [
+	"linked",
+	"inline",
+	"external",
+	"none"
+];
+const MIN_VITE_MAJOR = 8;
+/**
+* Validate the loaded ElectroConfig for structural issues.
+* Exits on fatal problems, warns on non-fatal ones.
+*/
+function validateConfig(config) {
+	const mainEntry = resolve(dirname(config.runtime.__source), config.runtime.entry);
+	if (!existsSync(mainEntry)) {
+		error(`Main entry not found: ${mainEntry}`);
+		process.exit(1);
+	}
+	const windows = config.windows ?? [];
+	const names = /* @__PURE__ */ new Set();
+	for (const win of windows) {
+		if (names.has(win.name)) {
+			error(`Duplicate window name "${win.name}". Window names must be unique.`);
+			process.exit(1);
+		}
+		names.add(win.name);
+	}
+	for (const win of windows) {
+		const winEntry = resolve(dirname(win.__source), win.entry);
+		if (!existsSync(winEntry)) {
+			error(`Window "${win.name}" entry not found: ${winEntry}`);
+			process.exit(1);
+		}
+	}
+	for (const win of windows) if (win.features && win.features.length === 0) warn(`Window "${win.name}" has an empty features array — it won't have access to any services.`);
+}
+/** Validate --sourcemap CLI value. Warns on unrecognized values. */
+function validateSourcemap(value) {
+	if (!VALID_SOURCEMAP_VALUES.includes(value)) warn(`Unknown --sourcemap value "${value}". Valid values: ${VALID_SOURCEMAP_VALUES.join(", ")}. Defaulting to "linked".`);
+}
+/**
+* Validate merged Vite config for a Node scope (main/preload).
+* Called after mergeConfig but before the config is used.
+* Throws on invalid settings that would break electro invariants.
+*/
+function validateMergedNodeConfig(config, scope) {
+	const target = config.build?.target;
+	if (target) {
+		const targets = Array.isArray(target) ? target : [target];
+		for (const t of targets) if (typeof t === "string" && t !== "esnext") throw new Error(`[electro] ${scope}: invalid target "${t}". Electro requires target: "esnext" (Electron 40+). Remove the target override from your config.`);
+	}
+	const rolldownOpts = config.build?.rolldownOptions;
+	if (rolldownOpts && typeof rolldownOpts === "object" && !Array.isArray(rolldownOpts)) {
+		const output = rolldownOpts.output;
+		if (output && typeof output === "object" && !Array.isArray(output)) {
+			const fmt = output.format;
+			if (fmt && fmt !== "es") throw new Error(`[electro] ${scope}: invalid output format "${fmt}". Electro is ESM-only (format: "es"). Remove the format override from your config.`);
+		}
+	}
+	if (config.ssr === false || config.build?.ssr === false) throw new Error(`[electro] ${scope}: SSR cannot be disabled in Node scopes. SSR mode is required for correct Node.js module resolution.`);
+}
+/**
+* Enforce electro invariants after merge — normalization pass.
+* Silently corrects values that must be fixed for correct operation.
+* Called AFTER validateMergedNodeConfig (which throws on user errors).
+*/
+function enforceMergedNodeConfig(config, _scope) {
+	const build = config.build;
+	if (!build) return;
+	if (build.target !== "esnext") build.target = "esnext";
+	const rolldownOpts = build.rolldownOptions;
+	if (rolldownOpts) {
+		const output = rolldownOpts.output;
+		if (output && output.format !== "es") output.format = "es";
+	}
+	if (!build.ssr) build.ssr = true;
+}
+/** Validate that installed Vite version is within the supported range. */
+function validateViteVersion(viteVersion) {
+	const majorRaw = viteVersion.split(".", 1)[0];
+	const major = Number.parseInt(majorRaw ?? "", 10);
+	if (!Number.isFinite(major) || major < MIN_VITE_MAJOR) {
+		error(`Unsupported Vite version: ${viteVersion}. @cordy/electro requires Vite ${MIN_VITE_MAJOR}+.`);
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/dev/config-loader.ts
+async function loadConfig(configPath) {
+	const absolutePath = resolve(process.cwd(), configPath);
+	const root = dirname(absolutePath);
+	if (!existsSync(absolutePath)) throw new Error(`Config file not found: ${absolutePath}`);
+	const config = (await import(absolutePath)).default;
+	if (!config) throw new Error(`${configPath} must have a default export`);
+	if (!config.runtime) throw new Error(`${configPath} must define a runtime via defineRuntime()`);
+	validateConfig(config);
+	return {
+		config,
+		configPath: absolutePath,
+		root
+	};
+}
+//#endregion
+//#region src/dev/externals.ts
+/**
+* Resolve externals for Node scope builds (main/preload).
+*
+* Auto-externalizes: electron, Node builtins (bare + node: prefixed),
+* package.json dependencies + optionalDependencies, and deep imports (pkg/subpath).
+*/
+async function resolveExternals(root) {
+	const pkgPath = resolve(root, "package.json");
+	const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+	const deps = new Set([
+		"electron",
+		...Object.keys(pkg.dependencies ?? {}),
+		...Object.keys(pkg.optionalDependencies ?? {})
+	]);
+	const builtins = builtinModules.flatMap((m) => [m, `node:${m}`]);
+	const depsArray = [...deps];
+	const deepPattern = depsArray.length > 0 ? new RegExp(`^(${depsArray.map(escapeRegExp).join("|")})/.+`) : null;
+	return deepPattern ? [
+		...depsArray,
+		...builtins,
+		deepPattern
+	] : [...depsArray, ...builtins];
+}
+function escapeRegExp(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/dev/vite-node-config.ts
+function resolveSourcemap$1(mode) {
+	if (!mode || mode === "linked" || mode === "external") return true;
+	if (mode === "inline") return "inline";
+	if (mode === "none") return false;
+	return true;
+}
+function createNodeConfig(opts) {
+	const resolveConditions = opts.scope === "preload" ? [
+		"node",
+		"import",
+		"default"
+	] : ["node", "import"];
+	const envPrefix = opts.scope === "main" ? ["MAIN_VITE_", "VITE_"] : ["PRELOAD_VITE_", "VITE_"];
+	const config = {
+		configFile: false,
+		root: opts.root,
+		plugins: opts.plugins ?? [],
+		customLogger: opts.customLogger,
+		envPrefix,
+		define: {
+			"process.env": "process.env",
+			...opts.define
+		},
+		build: {
+			ssr: opts.entry,
+			ssrEmitAssets: true,
+			outDir: opts.outDir,
+			emptyOutDir: true,
+			rolldownOptions: {
+				output: {
+					format: "es",
+					entryFileNames: "index.mjs"
+				},
+				external: opts.externals
+			},
+			target: "esnext",
+			sourcemap: resolveSourcemap$1(opts.sourcemap),
+			minify: false,
+			modulePreload: false,
+			watch: opts.watch ? {} : null,
+			reportCompressedSize: !opts.watch
+		},
+		ssr: {
+			target: "node",
+			noExternal: []
+		},
+		resolve: { conditions: resolveConditions },
+		logLevel: opts.logLevel ?? "warn",
+		clearScreen: opts.clearScreen
+	};
+	if (opts.scope === "main") {
+		const resourcesDir = resolve(opts.root, "resources");
+		if (existsSync(resourcesDir)) config.publicDir = resourcesDir;
+	}
+	if (opts.userViteConfig) {
+		const merged = mergeConfig(config, opts.userViteConfig);
+		validateMergedNodeConfig(merged, opts.scope);
+		enforceMergedNodeConfig(merged, opts.scope);
+		return merged;
+	}
+	return config;
+}
+//#endregion
+//#region src/dev/vite-renderer-config.ts
+function resolveSourcemap(mode) {
+	if (!mode || mode === "linked" || mode === "external") return true;
+	if (mode === "inline") return "inline";
+	if (mode === "none") return false;
+	return true;
+}
+function createRendererConfig(opts) {
+	const input = {};
+	for (const win of opts.windows) {
+		const sourceDir = dirname(win.__source);
+		input[win.name] = resolve(sourceDir, win.entry);
+	}
+	const isBuild = !!opts.outDir;
+	const config = {
+		configFile: false,
+		root: opts.root,
+		customLogger: opts.customLogger,
+		envPrefix: ["RENDERER_VITE_", "VITE_"],
+		...!isBuild && { server: { strictPort: false } },
+		...isBuild && { base: "./" },
+		build: {
+			rolldownOptions: { input },
+			...isBuild && {
+				outDir: opts.outDir,
+				emptyOutDir: true,
+				minify: opts.minify ?? true,
+				sourcemap: resolveSourcemap(opts.sourcemap),
+				reportCompressedSize: true,
+				modulePreload: { polyfill: false }
+			}
+		},
+		logLevel: opts.logLevel ?? "info",
+		clearScreen: opts.clearScreen
+	};
+	if (opts.userViteConfigs?.length) {
+		let merged = config;
+		for (const userConfig of opts.userViteConfigs) merged = mergeConfig(merged, userConfig);
+		return merged;
+	}
+	return config;
+}
+//#endregion
+//#region ../../node_modules/.bun/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function encodeInteger(builder, num, relative) {
+	let delta = num - relative;
+	delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+	do {
+		let clamped = delta & 31;
+		delta >>>= 5;
+		if (delta > 0) clamped |= 32;
+		builder.write(intToChar[clamped]);
+	} while (delta > 0);
+	return num;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { decode(buf) {
+	return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
+} } : { decode(buf) {
+	let out = "";
+	for (let i = 0; i < buf.length; i++) out += String.fromCharCode(buf[i]);
+	return out;
+} };
+var StringWriter = class {
+	constructor() {
+		this.pos = 0;
+		this.out = "";
+		this.buffer = new Uint8Array(bufLength);
+	}
+	write(v) {
+		const { buffer } = this;
+		buffer[this.pos++] = v;
+		if (this.pos === bufLength) {
+			this.out += td.decode(buffer);
+			this.pos = 0;
+		}
+	}
+	flush() {
+		const { buffer, out, pos } = this;
+		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+	}
+};
+function encode(decoded) {
+	const writer = new StringWriter();
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		if (line.length === 0) continue;
+		let genColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) writer.write(comma);
+			genColumn = encodeInteger(writer, segment[0], genColumn);
+			if (segment.length === 1) continue;
+			sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+			sourceLine = encodeInteger(writer, segment[2], sourceLine);
+			sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+			if (segment.length === 4) continue;
+			namesIndex = encodeInteger(writer, segment[4], namesIndex);
+		}
+	}
+	return writer.flush();
+}
+//#endregion
+//#region ../../node_modules/.bun/magic-string@0.30.21/node_modules/magic-string/dist/magic-string.es.mjs
+var BitSet = class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+	has(n) {
+		return !!(this.bits[n >> 5] & 1 << (n & 31));
+	}
+};
+var Chunk = class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+		this.intro = "";
+		this.outro = "";
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+		this.previous = null;
+		this.next = null;
+	}
+	appendLeft(content) {
+		this.outro += content;
+	}
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+		return chunk;
+	}
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+	eachNext(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+	eachPrevious(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = "";
+			this.outro = "";
+		}
+		this.storeName = storeName;
+		this.edited = true;
+		return this;
+	}
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+	reset() {
+		this.intro = "";
+		this.outro = "";
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+	split(index) {
+		const sliceIndex = index - this.start;
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+		this.original = originalBefore;
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = "";
+		this.end = index;
+		if (this.edited) {
+			newChunk.edit("", false);
+			this.content = "";
+		} else this.content = originalBefore;
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+		return newChunk;
+	}
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, "");
+		if (this.outro.length) return true;
+		const trimmed = this.content.replace(rx, "");
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				this.split(this.start + trimmed.length).edit("", void 0, true);
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+			}
+			return true;
+		} else {
+			this.edit("", void 0, true);
+			this.intro = this.intro.replace(rx, "");
+			if (this.intro.length) return true;
+		}
+	}
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, "");
+		if (this.intro.length) return true;
+		const trimmed = this.content.replace(rx, "");
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				const newChunk = this.split(this.end - trimmed.length);
+				if (this.edited) newChunk.edit(trimmed, this.storeName, true);
+				this.edit("", void 0, true);
+			}
+			return true;
+		} else {
+			this.edit("", void 0, true);
+			this.outro = this.outro.replace(rx, "");
+			if (this.outro.length) return true;
+		}
+	}
+};
+function getBtoa() {
+	if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	else if (typeof Buffer === "function") return (str) => Buffer.from(str, "utf-8").toString("base64");
+	else return () => {
+		throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+	};
+}
+const btoa = /* @__PURE__ */ getBtoa();
+var SourceMap = class {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== "undefined") this.x_google_ignoreList = properties.x_google_ignoreList;
+		if (typeof properties.debugId !== "undefined") this.debugId = properties.debugId;
+	}
+	toString() {
+		return JSON.stringify(this);
+	}
+	toUrl() {
+		return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
+	}
+};
+function guessIndent(code) {
+	const lines = code.split("\n");
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+	if (tabbed.length === 0 && spaced.length === 0) return null;
+	if (tabbed.length >= spaced.length) return "	";
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+	return new Array(min + 1).join(" ");
+}
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+	fromParts.pop();
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = "..";
+	}
+	return fromParts.concat(toParts).join("/");
+}
+const toString = Object.prototype.toString;
+function isObject(thing) {
+	return toString.call(thing) === "[object Object]";
+}
+function getLocator(source) {
+	const originalLines = source.split("\n");
+	const lineOffsets = [];
+	for (let i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
+	}
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = i + j >> 1;
+			if (index < lineOffsets[m]) j = m;
+			else i = m + 1;
+		}
+		const line = i - 1;
+		return {
+			line,
+			column: index - lineOffsets[line]
+		};
+	};
+}
+const wordRegex = /\w/;
+var Mappings = class {
+	constructor(hires) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.pending = null;
+	}
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf("\n", 0);
+			let previousContentLineEnd = -1;
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				];
+				if (nameIndex >= 0) segment.push(nameIndex);
+				this.rawSegments.push(segment);
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+			}
+			const segment = [
+				this.generatedCodeColumn,
+				sourceIndex,
+				loc.line,
+				loc.column
+			];
+			if (nameIndex >= 0) segment.push(nameIndex);
+			this.rawSegments.push(segment);
+			this.advance(content.slice(previousContentLineEnd + 1));
+		} else if (this.pending) {
+			this.rawSegments.push(this.pending);
+			this.advance(content);
+		}
+		this.pending = null;
+	}
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		let originalCharIndex = chunk.start;
+		let first = true;
+		let charInHiresBoundary = false;
+		while (originalCharIndex < chunk.end) {
+			if (original[originalCharIndex] === "\n") {
+				loc.line += 1;
+				loc.column = 0;
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				first = true;
+				charInHiresBoundary = false;
+			} else {
+				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+					const segment = [
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					];
+					if (this.hires === "boundary") if (wordRegex.test(original[originalCharIndex])) {
+						if (!charInHiresBoundary) {
+							this.rawSegments.push(segment);
+							charInHiresBoundary = true;
+						}
+					} else {
+						this.rawSegments.push(segment);
+						charInHiresBoundary = false;
+					}
+					else this.rawSegments.push(segment);
+				}
+				loc.column += 1;
+				this.generatedCodeColumn += 1;
+				first = false;
+			}
+			originalCharIndex += 1;
+		}
+		this.pending = null;
+	}
+	advance(str) {
+		if (!str) return;
+		const lines = str.split("\n");
+		if (lines.length > 1) {
+			for (let i = 0; i < lines.length - 1; i++) {
+				this.generatedCodeLine++;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+			}
+			this.generatedCodeColumn = 0;
+		}
+		this.generatedCodeColumn += lines[lines.length - 1].length;
+	}
+};
+const n = "\n";
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false
+};
+var MagicString = class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk(0, string.length, string);
+		Object.defineProperties(this, {
+			original: {
+				writable: true,
+				value: string
+			},
+			outro: {
+				writable: true,
+				value: ""
+			},
+			intro: {
+				writable: true,
+				value: ""
+			},
+			firstChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastSearchedChunk: {
+				writable: true,
+				value: chunk
+			},
+			byStart: {
+				writable: true,
+				value: {}
+			},
+			byEnd: {
+				writable: true,
+				value: {}
+			},
+			filename: {
+				writable: true,
+				value: options.filename
+			},
+			indentExclusionRanges: {
+				writable: true,
+				value: options.indentExclusionRanges
+			},
+			sourcemapLocations: {
+				writable: true,
+				value: new BitSet()
+			},
+			storedNames: {
+				writable: true,
+				value: {}
+			},
+			indentStr: {
+				writable: true,
+				value: void 0
+			},
+			ignoreList: {
+				writable: true,
+				value: options.ignoreList
+			},
+			offset: {
+				writable: true,
+				value: options.offset || 0
+			}
+		});
+		this.byStart[0] = chunk;
+		this.byEnd[string.length] = chunk;
+	}
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+	append(content) {
+		if (typeof content !== "string") throw new TypeError("outro content must be a string");
+		this.outro += content;
+		return this;
+	}
+	appendLeft(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		this._split(index);
+		const chunk = this.byEnd[index];
+		if (chunk) chunk.appendLeft(content);
+		else this.intro += content;
+		return this;
+	}
+	appendRight(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		this._split(index);
+		const chunk = this.byStart[index];
+		if (chunk) chunk.appendRight(content);
+		else this.outro += content;
+		return this;
+	}
+	clone() {
+		const cloned = new MagicString(this.original, {
+			filename: this.filename,
+			offset: this.offset
+		});
+		let originalChunk = this.firstChunk;
+		let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+		while (originalChunk) {
+			cloned.byStart[clonedChunk.start] = clonedChunk;
+			cloned.byEnd[clonedChunk.end] = clonedChunk;
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+				clonedChunk = nextClonedChunk;
+			}
+			originalChunk = nextOriginalChunk;
+		}
+		cloned.lastChunk = clonedChunk;
+		if (this.indentExclusionRanges) cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+		return cloned;
+	}
+	generateDecodedMap(options) {
+		options = options || {};
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const mappings = new Mappings(options.hires);
+		const locate = getLocator(this.original);
+		if (this.intro) mappings.advance(this.intro);
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+			if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+			else mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+		if (this.outro) mappings.advance(this.outro);
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+			sources: [options.source ? getRelativePath(options.file || "", options.source) : options.file || ""],
+			sourcesContent: options.includeContent ? [this.original] : void 0,
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+		};
+	}
+	generateMap(options) {
+		return new SourceMap(this.generateDecodedMap(options));
+	}
+	_ensureindentStr() {
+		if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
+	}
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? "	" : this.indentStr;
+	}
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+		if (isObject(indentStr)) {
+			options = indentStr;
+			indentStr = void 0;
+		}
+		if (indentStr === void 0) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || "	";
+		}
+		if (indentStr === "") return this;
+		options = options || {};
+		const isExcluded = {};
+		if (options.exclude) (typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude).forEach((exclusion) => {
+			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
+		});
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const replacer = (match) => {
+			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+			shouldIndentNextCharacter = true;
+			return match;
+		};
+		this.intro = this.intro.replace(pattern, replacer);
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			const end = chunk.end;
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) {
+					chunk.content = chunk.content.replace(pattern, replacer);
+					if (chunk.content.length) shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
+				}
+			} else {
+				charIndex = chunk.start;
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original[charIndex];
+						if (char === "\n") shouldIndentNextCharacter = true;
+						else if (char !== "\r" && shouldIndentNextCharacter) {
+							shouldIndentNextCharacter = false;
+							if (charIndex === chunk.start) chunk.prependRight(indentStr);
+							else {
+								this._splitChunk(chunk, charIndex);
+								chunk = chunk.next;
+								chunk.prependRight(indentStr);
+							}
+						}
+					}
+					charIndex += 1;
+				}
+			}
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+		this.outro = this.outro.replace(pattern, replacer);
+		return this;
+	}
+	insert() {
+		throw new Error("magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)");
+	}
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
+			warned.insertLeft = true;
+		}
+		return this.appendLeft(index, content);
+	}
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
+			warned.insertRight = true;
+		}
+		return this.prependRight(index, content);
+	}
+	move(start, end, index) {
+		start = start + this.offset;
+		end = end + this.offset;
+		index = index + this.offset;
+		if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
+		this._split(start);
+		this._split(end);
+		this._split(index);
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+		const newRight = this.byStart[index];
+		if (!newRight && last === this.lastChunk) return this;
+		const newLeft = newRight ? newRight.previous : this.lastChunk;
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+		first.previous = newLeft;
+		last.next = newRight || null;
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		return this;
+	}
+	overwrite(start, end, content, options) {
+		options = options || {};
+		return this.update(start, end, content, {
+			...options,
+			overwrite: !options.contentOnly
+		});
+	}
+	update(start, end, content, options) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (typeof content !== "string") throw new TypeError("replacement content must be a string");
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+		if (end > this.original.length) throw new Error("end is out of bounds");
+		if (start === end) throw new Error("Cannot overwrite a zero-length range – use appendLeft or prependRight instead");
+		this._split(start);
+		this._split(end);
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn("The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string");
+				warned.storeName = true;
+			}
+			options = { storeName: true };
+		}
+		const storeName = options !== void 0 ? options.storeName : false;
+		const overwrite = options !== void 0 ? options.overwrite : false;
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true
+			});
+		}
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart[chunk.end]) throw new Error("Cannot overwrite across a split point");
+				chunk = chunk.next;
+				chunk.edit("", false);
+			}
+			first.edit(content, storeName, !overwrite);
+		} else {
+			const newChunk = new Chunk(start, end, "").edit(content, storeName);
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+	prepend(content) {
+		if (typeof content !== "string") throw new TypeError("outro content must be a string");
+		this.intro = content + this.intro;
+		return this;
+	}
+	prependLeft(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		this._split(index);
+		const chunk = this.byEnd[index];
+		if (chunk) chunk.prependLeft(content);
+		else this.intro = content + this.intro;
+		return this;
+	}
+	prependRight(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		this._split(index);
+		const chunk = this.byStart[index];
+		if (chunk) chunk.prependRight(content);
+		else this.outro = content + this.outro;
+		return this;
+	}
+	remove(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+		if (start === end) return this;
+		if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+		if (start > end) throw new Error("end must be greater than start");
+		this._split(start);
+		this._split(end);
+		let chunk = this.byStart[start];
+		while (chunk) {
+			chunk.intro = "";
+			chunk.outro = "";
+			chunk.edit("");
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+	reset(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+		if (start === end) return this;
+		if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+		if (start > end) throw new Error("end must be greater than start");
+		this._split(start);
+		this._split(end);
+		let chunk = this.byStart[start];
+		while (chunk) {
+			chunk.reset();
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+		} while (chunk = chunk.previous);
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return "";
+	}
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+		} while (chunk = chunk.previous);
+		lineIndex = this.intro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+	slice(start = 0, end = this.original.length - this.offset) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+		let result = "";
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			if (chunk.start < end && chunk.end >= end) return result;
+			chunk = chunk.next;
+		}
+		if (chunk && chunk.edited && chunk.start !== start) throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+		const startChunk = chunk;
+		while (chunk) {
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) result += chunk.intro;
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end) throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+			result += chunk.content.slice(sliceStart, sliceEnd);
+			if (chunk.outro && (!containsEnd || chunk.end === end)) result += chunk.outro;
+			if (containsEnd) break;
+			chunk = chunk.next;
+		}
+		return result;
+	}
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+		return clone;
+	}
+	_split(index) {
+		if (this.byStart[index] || this.byEnd[index]) return;
+		let chunk = this.lastSearchedChunk;
+		let previousChunk = chunk;
+		const searchForward = index > chunk.end;
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+			if (chunk === previousChunk) return;
+			previousChunk = chunk;
+		}
+	}
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			const loc = getLocator(this.original)(index);
+			throw new Error(`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
+		}
+		const newChunk = chunk.split(index);
+		this.byEnd[index] = chunk;
+		this.byStart[index] = newChunk;
+		this.byEnd[newChunk.end] = newChunk;
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+	toString() {
+		let str = this.intro;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+		return str + this.outro;
+	}
+	isEmpty() {
+		let chunk = this.firstChunk;
+		do
+			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
+		while (chunk = chunk.next);
+		return true;
+	}
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		do
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+		while (chunk = chunk.next);
+		return length;
+	}
+	trimLines() {
+		return this.trim("[\\r\\n]");
+	}
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+	trimEndAborted(charType) {
+		const rx = new RegExp((charType || "\\s") + "+$");
+		this.outro = this.outro.replace(rx, "");
+		if (this.outro.length) return true;
+		let chunk = this.lastChunk;
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) this.lastChunk = chunk.next;
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+		return false;
+	}
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	trimStartAborted(charType) {
+		const rx = new RegExp("^" + (charType || "\\s") + "+");
+		this.intro = this.intro.replace(rx, "");
+		if (this.intro.length) return true;
+		let chunk = this.firstChunk;
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+			if (chunk.end !== end) {
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+		return false;
+	}
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+	hasChanged() {
+		return this.original !== this.toString();
+	}
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === "string") return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+				if (i === "$") return "$";
+				if (i === "&") return match[0];
+				if (+i < match.length) return match[+i];
+				return `$${i}`;
+			});
+			else return replacement(...match, match.index, str, match.groups);
+		}
+		function matchAll(re, str) {
+			let match;
+			const matches = [];
+			while (match = re.exec(str)) matches.push(match);
+			return matches;
+		}
+		if (searchValue.global) matchAll(searchValue, this.original).forEach((match) => {
+			if (match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
+			}
+		});
+		else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
+			}
+		}
+		return this;
+	}
+	_replaceString(string, replacement) {
+		const { original } = this;
+		const index = original.indexOf(string);
+		if (index !== -1) {
+			if (typeof replacement === "function") replacement = replacement(string, index, original);
+			if (string !== replacement) this.overwrite(index, index + string.length, replacement);
+		}
+		return this;
+	}
+	replace(searchValue, replacement) {
+		if (typeof searchValue === "string") return this._replaceString(searchValue, replacement);
+		return this._replaceRegexp(searchValue, replacement);
+	}
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+			const previous = original.slice(index, index + stringLength);
+			let _replacement = replacement;
+			if (typeof replacement === "function") _replacement = replacement(previous, index, original);
+			if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
+		}
+		return this;
+	}
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === "string") return this._replaceAllString(searchValue, replacement);
+		if (!searchValue.global) throw new TypeError("MagicString.prototype.replaceAll called with a non-global RegExp argument");
+		return this._replaceRegexp(searchValue, replacement);
+	}
+};
+//#endregion
+//#region src/plugins/utils.ts
+/** Strip query and hash from a URL/path. */
+function cleanUrl(url) {
+	return url.split("?")[0].split("#")[0];
+}
+/** Get a relative path from an importer chunk to a target file, always prefixed with `.` */
+function toRelativePath(from, to) {
+	const rel = relative(dirname(from), to);
+	return rel.startsWith(".") ? rel : `./${rel}`;
+}
+//#endregion
+//#region src/plugins/asset.ts
+const ASSET_QUERY_RE = /[?&]asset(?:&|$)/;
+const ASSET_IMPORT_RE = /(?:[?&]asset(?:&|$)|\.node$)/;
+const ASSET_PLACEHOLDER_RE = /__ELECTRO_ASSET__([\w$]+)__/g;
+function assetPlugin() {
+	const assetCache = /* @__PURE__ */ new Map();
+	return {
+		name: "electro:asset",
+		apply: "build",
+		async load(id) {
+			if (id.startsWith("\0") || !ASSET_IMPORT_RE.test(id)) return;
+			const file = cleanUrl(id);
+			let referenceId;
+			const cached = assetCache.get(file);
+			if (cached) referenceId = cached;
+			else {
+				const source = await readFile(file);
+				referenceId = `__ELECTRO_ASSET__${this.emitFile({
+					type: "asset",
+					name: basename(file),
+					source
+				})}__`;
+				assetCache.set(file, referenceId);
+			}
+			if (ASSET_QUERY_RE.test(id)) return [`import { join } from "node:path"`, `export default join(import.meta.dirname, ${referenceId})`].join("\n");
+			if (id.endsWith(".node")) return [`const __require = process.getBuiltinModule("module").createRequire(import.meta.url)`, `export default __require(new URL(${referenceId}, import.meta.url).pathname)`].join("\n");
+		},
+		renderChunk(code, chunk) {
+			ASSET_PLACEHOLDER_RE.lastIndex = 0;
+			let match = ASSET_PLACEHOLDER_RE.exec(code);
+			if (!match) return null;
+			const s = new MagicString(code);
+			while (match) {
+				const [full, hash] = match;
+				const filename = this.getFileName(hash);
+				const replacement = JSON.stringify(toRelativePath(chunk.fileName, filename));
+				s.overwrite(match.index, match.index + full.length, replacement, { contentOnly: true });
+				match = ASSET_PLACEHOLDER_RE.exec(code);
+			}
+			return {
+				code: s.toString(),
+				map: s.generateMap({ hires: "boundary" })
+			};
+		}
+	};
+}
+//#endregion
+//#region src/dev/electron-launcher.ts
+async function fileExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Find the Electron binary. Resolution order:
+* 1. ELECTRON_EXEC_PATH env var
+* 2. electron/path.txt (npm package convention)
+* 3. node_modules/.bin/electron symlink
+*/
+async function findElectronBin(root) {
+	if (process.env.ELECTRON_EXEC_PATH) return process.env.ELECTRON_EXEC_PATH;
+	try {
+		const electronDir = resolve(root, "node_modules/electron");
+		const pathTxtPath = resolve(electronDir, "path.txt");
+		if (await fileExists(pathTxtPath)) {
+			const resolved = resolve(electronDir, (await readFile(pathTxtPath, "utf-8")).trim());
+			if (await fileExists(resolved)) return resolved;
+		}
+	} catch {}
+	const binSymlink = resolve(root, "node_modules/.bin/electron");
+	if (await fileExists(binSymlink)) return binSymlink;
+	throw new Error("Could not find Electron binary. Install electron: npm add -D electron");
+}
+const yellow = "\x1B[33m";
+const red = "\x1B[31m";
+const dim = "\x1B[90m";
+const reset = "\x1B[0m";
+const DIAG_RE = new RegExp(String.raw`^(\d{2}:\d{2}:\d{2}) \[(electro|warn|error)\] (.+?) \u2192 (.+)$`);
+function colorDiagnosticLine(line) {
+	const match = line.match(DIAG_RE);
+	if (!match) return line;
+	const [, time, tag, code, message] = match;
+	let coloredTag;
+	if (tag === "error") coloredTag = `${red}[${tag}]${reset}`;
+	else if (tag === "warn") coloredTag = `${yellow}[${tag}]${reset}`;
+	else coloredTag = `${yellow}[${tag}]${reset}`;
+	return `${dim}${time}${reset} ${coloredTag} ${dim}${code}${reset} \u2192 ${message}`;
+}
+function pipeWithColoring(stream, target) {
+	let buffer = "";
+	stream.on("data", (chunk) => {
+		buffer += chunk.toString();
+		const lines = buffer.split("\n");
+		buffer = lines.pop() ?? "";
+		for (const line of lines) target.write(`${colorDiagnosticLine(line)}\n`);
+	});
+	stream.on("end", () => {
+		if (buffer) target.write(`${colorDiagnosticLine(buffer)}\n`);
+	});
+}
+async function launchElectron(opts) {
+	const proc = spawn(await findElectronBin(opts.root), [opts.entry], {
+		cwd: opts.root,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		env: {
+			...process.env,
+			...opts.env
+		}
+	});
+	if (proc.stdout) pipeWithColoring(proc.stdout, process.stdout);
+	if (proc.stderr) pipeWithColoring(proc.stderr, process.stderr);
+	return {
+		kill: () => proc.kill(),
+		exited: new Promise((resolve) => {
+			proc.on("exit", (code) => resolve(code));
+			proc.on("error", () => resolve(null));
+		})
+	};
+}
+//#endregion
+//#region src/plugins/bytecode.ts
+const BYTECODE_LOADER_FILE = "bytecode-loader.cjs";
+/**
+* CJS module that registers `.jsc` file extension handler.
+* Loaded at runtime via createRequire before bytecode modules are required.
+*/
+const BYTECODE_LOADER_CODE = [
+	`"use strict";`,
+	`const fs = require("fs");`,
+	`const path = require("path");`,
+	`const vm = require("vm");`,
+	`const v8 = require("v8");`,
+	`const Module = require("module");`,
+	``,
+	`v8.setFlagsFromString("--no-lazy");`,
+	`v8.setFlagsFromString("--no-flush-bytecode");`,
+	``,
+	`const FLAG_HASH_OFFSET = 12;`,
+	`const SOURCE_HASH_OFFSET = 8;`,
+	``,
+	`let dummyBytecode;`,
+	`function fixFlagHash(buffer) {`,
+	`  if (!dummyBytecode) {`,
+	`    dummyBytecode = new vm.Script("", { produceCachedData: true }).createCachedData();`,
+	`  }`,
+	`  dummyBytecode.copy(buffer, FLAG_HASH_OFFSET, FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4);`,
+	`}`,
+	``,
+	`Module._extensions[".jsc"] = function(module, filename) {`,
+	`  const bytecode = fs.readFileSync(filename);`,
+	`  fixFlagHash(bytecode);`,
+	`  const sourceLength = bytecode.readUInt32LE(SOURCE_HASH_OFFSET);`,
+	`  const dummyCode = sourceLength > 1 ? '"' + "\\u200b".repeat(sourceLength - 2) + '"' : "";`,
+	`  const script = new vm.Script(dummyCode, { filename, cachedData: bytecode });`,
+	`  if (script.cachedDataRejected) {`,
+	`    throw new Error("Bytecode cache rejected (V8 version mismatch?): " + filename);`,
+	`  }`,
+	`  const wrapper = script.runInThisContext({ filename });`,
+	`  const dir = path.dirname(filename);`,
+	`  wrapper.apply(module.exports, [module.exports, module.require.bind(module), module, filename, dir]);`,
+	`};`,
+	``
+].join("\n");
+/**
+* Script executed inside Electron (ELECTRON_RUN_AS_NODE=1) to compile JS to V8 bytecode.
+* Reads CJS code from stdin, writes bytecode buffer to stdout.
+*/
+const COMPILER_SCRIPT = [
+	`"use strict";`,
+	`const vm = require("vm");`,
+	`const v8 = require("v8");`,
+	`const Module = require("module");`,
+	``,
+	`v8.setFlagsFromString("--no-lazy");`,
+	`v8.setFlagsFromString("--no-flush-bytecode");`,
+	``,
+	`let code = "";`,
+	`process.stdin.setEncoding("utf-8");`,
+	`process.stdin.on("data", chunk => { code += chunk; });`,
+	`process.stdin.on("end", () => {`,
+	`  const wrapped = Module.wrap(code);`,
+	`  const script = new vm.Script(wrapped, { produceCachedData: true });`,
+	`  const bytecode = script.createCachedData();`,
+	`  process.stdout.write(bytecode);`,
+	`});`
+].join("\n");
+/**
+* Compile Node scope output to V8 bytecode for source code protection.
+*
+* Architecture:
+* 1. ESM chunk code → CJS transform (via Bun.build)
+* 2. CJS code → V8 bytecode (via Electron subprocess)
+* 3. Entry .js → thin ESM loader stub that requires the .jsc bytecode
+* 4. bytecode-loader.cjs → registers Module._extensions[".jsc"]
+*
+* Only active in production mode. Not applicable to renderer scope.
+*/
+function bytecodePlugin(options = {}) {
+	const { chunkAlias = [], keepSource = false, protectedStrings = [] } = options;
+	const compileAll = chunkAlias.length === 0;
+	const protectedSet = new Set(protectedStrings);
+	let logger;
+	let isProduction = false;
+	let projectRoot = "";
+	function shouldCompile(chunkName) {
+		return compileAll || chunkAlias.includes(chunkName);
+	}
+	return {
+		name: "electro:bytecode",
+		apply: "build",
+		enforce: "post",
+		configResolved(config) {
+			logger = config.logger;
+			isProduction = config.isProduction;
+			projectRoot = config.root;
+		},
+		renderChunk(code, chunk, opts) {
+			if (!isProduction || !shouldCompile(chunk.name) || protectedSet.size === 0) return null;
+			const s = obfuscateStrings(code, protectedSet);
+			if (!s) return null;
+			const sourcemap = typeof opts === "object" && "sourcemap" in opts ? opts.sourcemap : false;
+			return {
+				code: s.toString(),
+				map: sourcemap ? s.generateMap({ hires: "boundary" }) : void 0
+			};
+		},
+		async generateBundle(_outputOptions, output) {
+			if (!isProduction) return;
+			let electronPath;
+			try {
+				electronPath = await findElectronBin(projectRoot);
+			} catch {
+				try {
+					electronPath = await findElectronBin(join(projectRoot, "../.."));
+				} catch {}
+			}
+			if (!electronPath) {
+				logger.warn("[electro:bytecode] Electron binary not found — skipping bytecode compilation");
+				return;
+			}
+			const compilerPath = join(tmpdir(), `electro-bc-compiler-${process.pid}.cjs`);
+			await Bun.write(compilerPath, COMPILER_SCRIPT);
+			const chunks = [];
+			for (const item of Object.values(output)) if (item.type === "chunk" && item.isEntry && shouldCompile(item.name)) chunks.push(item);
+			if (chunks.length === 0) {
+				await cleanup(compilerPath);
+				return;
+			}
+			let compiledCount = 0;
+			for (const chunk of chunks) try {
+				const bytecode = await compileToBytecode(await esmToCjs(chunk.code), electronPath, compilerPath);
+				const jscFileName = `${chunk.fileName}c`;
+				this.emitFile({
+					type: "asset",
+					fileName: jscFileName,
+					source: bytecode
+				});
+				if (keepSource) this.emitFile({
+					type: "asset",
+					fileName: `_${chunk.fileName}`,
+					source: chunk.code
+				});
+				chunk.code = generateLoaderStub(relativeChunkPath(BYTECODE_LOADER_FILE, chunk.fileName), relativeChunkPath(jscFileName, chunk.fileName), chunk.exports);
+				compiledCount++;
+			} catch (e) {
+				logger.error(`[electro:bytecode] Failed to compile ${chunk.fileName}: ${e instanceof Error ? e.message : e}`);
+			}
+			if (compiledCount > 0) {
+				if (!Object.values(output).some((a) => a.type === "asset" && a.fileName === BYTECODE_LOADER_FILE)) this.emitFile({
+					type: "asset",
+					fileName: BYTECODE_LOADER_FILE,
+					source: BYTECODE_LOADER_CODE
+				});
+				logger.info(`\x1b[32m\u2713\x1b[0m ${compiledCount} chunk(s) compiled to bytecode`);
+			}
+			await cleanup(compilerPath);
+		}
+	};
+}
+/** Transform ESM code to CJS using Bun.build (packages stay external). */
+async function esmToCjs(code) {
+	const tmpFile = join(tmpdir(), `electro-bc-${process.pid}-${Date.now()}.mjs`);
+	await Bun.write(tmpFile, code);
+	try {
+		const result = await Bun.build({
+			entrypoints: [tmpFile],
+			format: "cjs",
+			target: "node",
+			packages: "external",
+			minify: false
+		});
+		if (!result.success) {
+			const msgs = result.logs.map((l) => l.message).join("\n");
+			throw new Error(`ESM\u2192CJS transform failed:\n${msgs}`);
+		}
+		return await result.outputs[0].text();
+	} finally {
+		await cleanup(tmpFile);
+	}
+}
+/** Compile CJS code to V8 bytecode via Electron subprocess. */
+async function compileToBytecode(code, electronPath, compilerPath) {
+	const proc = Bun.spawn([electronPath, compilerPath], {
+		env: {
+			...process.env,
+			ELECTRON_RUN_AS_NODE: "1"
+		},
+		stdin: new Blob([code]),
+		stdout: "pipe",
+		stderr: "pipe"
+	});
+	const [stdoutBuf, stderrText, exitCode] = await Promise.all([
+		new Response(proc.stdout).arrayBuffer(),
+		new Response(proc.stderr).text(),
+		proc.exited
+	]);
+	if (exitCode !== 0) throw new Error(`Bytecode compilation failed (exit ${exitCode}): ${stderrText}`);
+	const buf = Buffer.from(stdoutBuf);
+	if (buf.length === 0) throw new Error("Bytecode compilation returned empty buffer");
+	return buf;
+}
+/** Generate ESM entry stub that loads bytecode via createRequire. */
+function generateLoaderStub(loaderPath, jscPath, exports) {
+	const lines = [
+		`const __require = process.getBuiltinModule("module").createRequire(import.meta.url);`,
+		`__require(${JSON.stringify(loaderPath)});`,
+		`const __mod = __require(${JSON.stringify(jscPath)});`
+	];
+	if (exports.includes("default")) lines.push(`export default __mod["default"] ?? __mod;`);
+	const named = exports.filter((e) => e !== "default");
+	if (named.length > 0) lines.push(`export const { ${named.join(", ")} } = __mod;`);
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Obfuscate specific string literals via String.fromCharCode.
+*
+* Context-aware: skips strings that appear in unsafe positions:
+* - import/export specifiers: `import "pkg"`, `from "pkg"`
+* - require() arguments: `require("pkg")`
+* - computed member expressions: `obj["key"]`
+* - object literal keys: `{ "key": value }`
+*/
+function obfuscateStrings(code, strings) {
+	if (strings.size === 0) return null;
+	let s;
+	const stringRE = /"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'/g;
+	let match;
+	match = stringRE.exec(code);
+	while (match) {
+		const value = match[1] ?? match[2];
+		if (value && strings.has(value) && !isUnsafeContext(code, match.index, match[0].length)) {
+			s ??= new MagicString(code);
+			const charCodes = Array.from(value).map((c) => c.charCodeAt(0)).join(",");
+			s.overwrite(match.index, match.index + match[0].length, `String.fromCharCode(${charCodes})`, { contentOnly: true });
+		}
+		match = stringRE.exec(code);
+	}
+	return s ?? null;
+}
+/** Check if a string literal at the given position is in an unsafe context for obfuscation. */
+function isUnsafeContext(code, matchStart, matchLen) {
+	const before = code.slice(Math.max(0, matchStart - 80), matchStart).trimEnd();
+	if (/\bimport\s*$/.test(before) || /\bfrom\s*$/.test(before)) return true;
+	if (/\brequire\s*\(\s*$/.test(before)) return true;
+	if (before.endsWith("[")) return true;
+	if (code.slice(matchStart + matchLen, matchStart + matchLen + 20).trimStart().startsWith(":")) {
+		if (!before.endsWith("?")) return true;
+	}
+	return false;
+}
+/** Compute relative path from `from` file to `target` file. */
+function relativeChunkPath(target, from) {
+	let rel = relative(dirname(from), target);
+	if (!rel.startsWith(".")) rel = `./${rel}`;
+	return rel;
+}
+/** Silent cleanup of temp files. */
+async function cleanup(filePath) {
+	try {
+		await Bun.file(filePath).delete();
+	} catch {}
+}
+//#endregion
+//#region src/plugins/isolate-entries.ts
+const VIRTUAL_ENTRY_ID = "\0electro:isolate-entries";
+/**
+* Isolates multiple entry points into separate sub-builds.
+* Dormant (no-op) if only one entry detected.
+*/
+function isolateEntriesPlugin(subBuildConfig) {
+	const emitted = /* @__PURE__ */ new Set();
+	let entries = null;
+	return {
+		name: "electro:isolate-entries",
+		apply: "build",
+		options(opts) {
+			const { input } = opts;
+			if (!input || typeof input !== "object" || Array.isArray(input)) return;
+			if (Object.keys(input).length <= 1) return;
+			entries = Object.entries(input).map(([k, v]) => ({ [k]: v }));
+			opts.input = VIRTUAL_ENTRY_ID;
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_ENTRY_ID) return id;
+			return null;
+		},
+		async load(id) {
+			if (id !== VIRTUAL_ENTRY_ID || !entries) return;
+			for (const entry of entries) {
+				const config = mergeConfig(subBuildConfig, {
+					build: {
+						write: false,
+						watch: null
+					},
+					plugins: [{
+						name: "electro:entry-file-name",
+						outputOptions(output) {
+							if (output.entryFileNames && typeof output.entryFileNames === "string") output.entryFileNames = `[name]${extname(output.entryFileNames)}`;
+						}
+					}],
+					logLevel: "warn",
+					configFile: false
+				});
+				if (config.build) config.build.rolldownOptions = {
+					...config.build.rolldownOptions,
+					input: entry
+				};
+				const result = await build(config);
+				for (const chunk of result.output) {
+					if (emitted.has(chunk.fileName)) continue;
+					const source = chunk.type === "chunk" ? chunk.code : chunk.source;
+					if (source == null) continue;
+					this.emitFile({
+						type: "asset",
+						fileName: chunk.fileName,
+						source
+					});
+					emitted.add(chunk.fileName);
+				}
+			}
+			return "// virtual entry — removed in generateBundle";
+		},
+		generateBundle(_, bundle) {
+			for (const name in bundle) if (name.includes("isolate-entries")) delete bundle[name];
+		}
+	};
+}
+//#endregion
+//#region src/plugins/module-path.ts
+const MODULE_PATH_RE = /__ELECTRO_MODULE_PATH__([\w$]+)__/g;
+/** Plugins to exclude from sub-build configs to prevent recursion. */
+const EXCLUDED_PLUGINS = new Set([
+	"electro:module-path",
+	"electro:isolate-entries",
+	"electro:bytecode"
+]);
+/**
+* Handles `?modulePath` imports in main/preload scopes.
+*
+* Builds the referenced file as a fully isolated bundle via `viteBuild()`
+* and returns its runtime filesystem path. Guarantees self-contained output
+* with no shared chunks — safe for `child_process.fork()`.
+*
+* Usage:
+*   import taskPath from './task.ts?modulePath'
+*   fork(taskPath)
+*/
+function modulePathPlugin() {
+	const assetCache = /* @__PURE__ */ new Set();
+	let resolvedConfig;
+	return {
+		name: "electro:module-path",
+		apply: "build",
+		enforce: "pre",
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+		buildStart() {
+			assetCache.clear();
+		},
+		async load(id) {
+			if (!id.endsWith("?modulePath")) return;
+			const result = await bundleModulePath(cleanUrl(id), createSubBuildConfig(resolvedConfig), this.meta.watchMode);
+			const [mainChunk, ...otherChunks] = result.output;
+			const refId = this.emitFile({
+				type: "asset",
+				fileName: mainChunk.fileName,
+				source: mainChunk.code ?? ""
+			});
+			for (const chunk of otherChunks) {
+				if (assetCache.has(chunk.fileName)) continue;
+				const source = chunk.type === "chunk" ? chunk.code : chunk.source;
+				if (source == null) continue;
+				this.emitFile({
+					type: "asset",
+					fileName: chunk.fileName,
+					source
+				});
+				assetCache.add(chunk.fileName);
+			}
+			for (const watchFile of result.watchFiles) this.addWatchFile(watchFile);
+			return [`import { join } from 'path'`, `export default join(import.meta.dirname, ${`__ELECTRO_MODULE_PATH__${refId}__`})`].join("\n");
+		},
+		renderChunk(code, chunk, opts) {
+			MODULE_PATH_RE.lastIndex = 0;
+			let match = MODULE_PATH_RE.exec(code);
+			if (!match) return null;
+			const sourcemap = typeof opts === "object" && "sourcemap" in opts ? opts.sourcemap : false;
+			const s = new MagicString(code);
+			while (match) {
+				const [full, hash] = match;
+				const filename = this.getFileName(hash);
+				const replacement = JSON.stringify(toRelativePath(chunk.fileName, filename));
+				s.overwrite(match.index, match.index + full.length, replacement, { contentOnly: true });
+				match = MODULE_PATH_RE.exec(code);
+			}
+			return {
+				code: s.toString(),
+				map: sourcemap ? s.generateMap({ hires: "boundary" }) : null
+			};
+		}
+	};
+}
+/** Create a sub-build config from resolved config, stripping recursive plugins. */
+function createSubBuildConfig(config) {
+	const plugins = (config.plugins ?? []).filter((p) => !EXCLUDED_PLUGINS.has(p.name));
+	return {
+		configFile: false,
+		root: config.root,
+		mode: config.mode,
+		envDir: config.envDir,
+		envPrefix: config.envPrefix,
+		plugins,
+		resolve: config.resolve,
+		define: config.define,
+		build: {
+			ssr: config.build.ssr,
+			outDir: config.build.outDir,
+			rolldownOptions: {
+				output: config.build.rolldownOptions.output,
+				external: config.build.rolldownOptions.external
+			},
+			target: config.build.target,
+			sourcemap: config.build.sourcemap,
+			minify: config.build.minify
+		},
+		ssr: config.ssr,
+		logLevel: "warn"
+	};
+}
+/** Collect source files from a sub-build for watch-mode tracking. */
+function watchCollectorPlugin(watchFiles) {
+	return {
+		name: "electro:module-path-watch",
+		buildEnd() {
+			for (const id of this.getModuleIds()) {
+				if (id.includes("node_modules") || id.startsWith("\0")) continue;
+				if (this.getModuleInfo(id)?.code != null) watchFiles.push(id);
+			}
+		}
+	};
+}
+/** Build a ?modulePath import as a fully isolated bundle. */
+async function bundleModulePath(input, config, watch) {
+	const watchFiles = [];
+	const subConfig = mergeConfig(config, {
+		build: {
+			write: false,
+			watch: false
+		},
+		plugins: [{
+			name: "electro:module-path-entry-name",
+			outputOptions(output) {
+				if (typeof output.entryFileNames !== "function" && output.entryFileNames) output.entryFileNames = `[name]-[hash]${extname(output.entryFileNames)}`;
+			}
+		}, ...watch ? [watchCollectorPlugin(watchFiles)] : []],
+		logLevel: "warn",
+		configFile: false
+	});
+	if (subConfig.build) subConfig.build.rolldownOptions = {
+		...subConfig.build?.rolldownOptions,
+		input,
+		plugins: [...subConfig.build?.rolldownOptions?.plugins ?? []]
+	};
+	return {
+		output: (await build(subConfig)).output,
+		watchFiles
+	};
+}
+//#endregion
+//#region src/plugins/worker.ts
+const WORKER_PLACEHOLDER_RE = /__ELECTRO_WORKER__([\w$]+)__/g;
+const WORKER_QUERY_RE = /\?nodeWorker(?:&|$)/;
+const WORKER_IMPORTER_RE = /\?nodeWorker&importer=([^&]+)(?:&|$)/;
+/**
+* Handles `?nodeWorker` imports in main/preload scopes.
+*
+* Builds the referenced file as a separate chunk and returns
+* a factory function that creates a `worker_threads` Worker.
+*
+* Usage:
+*   import createWorker from './heavy-task.ts?nodeWorker'
+*   const worker = createWorker({ workerData: { ... } })
+*/
+function workerPlugin() {
+	return {
+		name: "electro:worker",
+		apply: "build",
+		enforce: "pre",
+		resolveId(id, importer) {
+			if (id.endsWith("?nodeWorker")) return `${id}&importer=${importer}`;
+		},
+		load(id) {
+			if (!WORKER_QUERY_RE.test(id)) return;
+			const match = WORKER_IMPORTER_RE.exec(id);
+			if (!match) return;
+			return [
+				`import { Worker } from 'worker_threads';`,
+				`export default function createWorker(options) {`,
+				`  return new Worker(new URL(${`__ELECTRO_WORKER__${this.emitFile({
+					type: "chunk",
+					id: cleanUrl(id),
+					importer: match[1]
+				})}__`}, import.meta.url), options);`,
+				`};`
+			].join("\n");
+		},
+		renderChunk(code, chunk, opts) {
+			WORKER_PLACEHOLDER_RE.lastIndex = 0;
+			let match = WORKER_PLACEHOLDER_RE.exec(code);
+			if (!match) return null;
+			const sourcemap = typeof opts === "object" && "sourcemap" in opts ? opts.sourcemap : false;
+			const s = new MagicString(code);
+			while (match) {
+				const [full, hash] = match;
+				const filename = this.getFileName(hash);
+				const replacement = JSON.stringify(toRelativePath(chunk.fileName, filename));
+				s.overwrite(match.index, match.index + full.length, replacement, { contentOnly: true });
+				match = WORKER_PLACEHOLDER_RE.exec(code);
+			}
+			return {
+				code: s.toString(),
+				map: sourcemap ? s.generateMap({ hires: "boundary" }) : null
+			};
+		}
+	};
+}
+//#endregion
+//#region src/commands/build.ts
+async function build$1(options) {
+	if (options.sourcemap) validateSourcemap(options.sourcemap);
+	if (options.logLevel) setLogLevel(options.logLevel);
+	const totalTimer = startTimer();
+	validateViteVersion(version);
+	const loaded = await loadConfig(options.config);
+	const config = loaded.config;
+	const root = loaded.root;
+	const outDir = resolve(root, options.outDir);
+	const codegenDir = resolve(root, ".electro");
+	const windows = config.windows ?? [];
+	const srcDir = resolve(root, "src");
+	session({
+		root,
+		main: resolve(dirname(config.runtime.__source), config.runtime.entry),
+		preload: windows.length > 0 ? resolve(codegenDir, "generated/preload") : null,
+		renderer: windows.length > 0 ? resolve(root, dirname(relative(root, windows[0].__source))) : null,
+		mode: "build",
+		windows: windows.map((w) => ({
+			name: w.name,
+			entry: resolve(dirname(w.__source), w.entry)
+		}))
+	});
+	const codegenTimer = startTimer();
+	try {
+		const { files, envTypes } = generate({
+			scanResult: await scan(srcDir),
+			windows,
+			outputDir: codegenDir,
+			srcDir
+		});
+		await mkdir(codegenDir, { recursive: true });
+		for (const file of files) {
+			const filePath = resolve(codegenDir, file.path);
+			await mkdir(dirname(filePath), { recursive: true });
+			await writeFile(filePath, file.content);
+		}
+		const envTypesPath = resolve(srcDir, envTypes.path);
+		await mkdir(dirname(envTypesPath), { recursive: true });
+		await writeFile(envTypesPath, envTypes.content);
+		step("codegen", codegenTimer());
+	} catch (err) {
+		stepFail("codegen", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	const externals = await resolveExternals(root);
+	const logger = createBuildLogger();
+	try {
+		buildScope("main");
+		await buildMain({
+			config,
+			root,
+			outDir,
+			externals,
+			sourcemap: options.sourcemap,
+			logger,
+			bytecode: options.bytecode
+		});
+	} catch (err) {
+		stepFail("main", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	if (windows.length > 0) try {
+		buildScope("preload");
+		await buildPreload({
+			config,
+			root,
+			outDir,
+			codegenDir,
+			externals,
+			sourcemap: options.sourcemap,
+			logger,
+			bytecode: options.bytecode
+		});
+	} catch (err) {
+		stepFail("preload", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	if (windows.length > 0) try {
+		buildScope("renderer");
+		const userViteConfigs = windows.filter((w) => w.vite).map((w) => w.vite);
+		await build(createRendererConfig({
+			root,
+			windows,
+			userViteConfigs: userViteConfigs.length > 0 ? userViteConfigs : void 0,
+			logLevel: "info",
+			customLogger: logger,
+			outDir: resolve(outDir, "renderer"),
+			minify: options.minify,
+			sourcemap: options.sourcemap
+		}));
+		await flattenRendererOutput(resolve(outDir, "renderer"), windows, root);
+	} catch (err) {
+		stepFail("renderer", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	footer(`Built in ${totalTimer()}`, outDir);
+}
+async function buildMain(args) {
+	const runtimeEntry = args.config.runtime.entry;
+	const entry = resolve(dirname(args.config.runtime.__source), runtimeEntry);
+	const windowDefs = (args.config.windows ?? []).map((w) => ({
+		name: w.name,
+		type: w.type,
+		lifecycle: w.lifecycle,
+		autoShow: w.autoShow,
+		behavior: w.behavior,
+		window: w.window
+	}));
+	await build(createNodeConfig({
+		scope: "main",
+		root: args.root,
+		entry,
+		externals: args.externals,
+		outDir: resolve(args.outDir, "main"),
+		watch: false,
+		plugins: [
+			assetPlugin(),
+			workerPlugin(),
+			modulePathPlugin(),
+			...args.bytecode ? [bytecodePlugin()] : []
+		],
+		userViteConfig: args.config.runtime.vite,
+		sourcemap: args.sourcemap,
+		customLogger: args.logger,
+		logLevel: "info",
+		define: { __ELECTRO_WINDOW_DEFINITIONS__: JSON.stringify(windowDefs) }
+	}));
+}
+async function buildPreload(args) {
+	const windows = args.config.windows ?? [];
+	const input = {};
+	for (const win of windows) input[win.name] = resolve(args.codegenDir, `generated/preload/${win.name}.gen.ts`);
+	const firstEntry = Object.values(input)[0];
+	const preloadOutDir = resolve(args.outDir, "preload");
+	const preloadPlugins = [
+		assetPlugin(),
+		workerPlugin(),
+		modulePathPlugin(),
+		...args.bytecode ? [bytecodePlugin()] : []
+	];
+	const baseConfig = createNodeConfig({
+		scope: "preload",
+		root: args.root,
+		entry: firstEntry,
+		externals: args.externals,
+		outDir: preloadOutDir,
+		watch: false,
+		plugins: preloadPlugins,
+		sourcemap: args.sourcemap,
+		customLogger: args.logger,
+		logLevel: "info"
+	});
+	if (Object.keys(input).length > 1) {
+		const subBuildConfig = createNodeConfig({
+			scope: "preload",
+			root: args.root,
+			entry: firstEntry,
+			externals: args.externals,
+			outDir: preloadOutDir,
+			watch: false,
+			plugins: [
+				assetPlugin(),
+				workerPlugin(),
+				modulePathPlugin()
+			],
+			sourcemap: args.sourcemap,
+			customLogger: args.logger,
+			logLevel: "info"
+		});
+		baseConfig.plugins.push(isolateEntriesPlugin(subBuildConfig));
+	}
+	if (baseConfig.build) baseConfig.build.rolldownOptions = {
+		...baseConfig.build.rolldownOptions,
+		input
+	};
+	await build(baseConfig);
+}
+/**
+* Flatten renderer HTML output from source-relative paths
+* (e.g., `src/windows/main/index.html`) to `{name}/index.html`.
+* Adjusts relative asset references to match the new depth.
+*/
+async function flattenRendererOutput(rendererDir, windows, root) {
+	const dirsToClean = /* @__PURE__ */ new Set();
+	for (const win of windows) {
+		const relPath = relative(root, resolve(dirname(win.__source), win.entry));
+		const oldHtmlPath = resolve(rendererDir, relPath);
+		const newHtmlPath = resolve(rendererDir, win.name, "index.html");
+		if (oldHtmlPath === newHtmlPath) continue;
+		let html = await readFile(oldHtmlPath, "utf-8");
+		const depthDiff = relPath.split("/").length - 1 - 1;
+		if (depthDiff > 0) html = html.replace(/(["'(])((?:\.\.\/)+)/g, (_, prefix, dots) => {
+			const levels = (dots.match(/\.\.\//g) || []).length;
+			const adjusted = Math.max(0, levels - depthDiff);
+			return prefix + (adjusted > 0 ? "../".repeat(adjusted) : "./");
+		});
+		await mkdir(dirname(newHtmlPath), { recursive: true });
+		await writeFile(newHtmlPath, html);
+		await unlink(oldHtmlPath);
+		const topDir = relPath.split("/")[0];
+		if (topDir !== win.name) dirsToClean.add(resolve(rendererDir, topDir));
+	}
+	for (const dir of dirsToClean) await rm(dir, {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/dev/dev-server.ts
+const MAIN_RESTART_DEBOUNCE_MS = 80;
+const CONFIG_DEBOUNCE_MS = 300;
+var DevServer = class {
+	rendererServer = null;
+	electronProcess = null;
+	config = null;
+	root = "";
+	lastScanResult = null;
+	shuttingDown = false;
+	cleanedUp = false;
+	restartInFlight = false;
+	restartQueued = false;
+	restartQueuedFile = null;
+	mainRestartQueued = false;
+	mainRestartReason = null;
+	mainRestartFlushTimer = null;
+	mainRestartFlushInFlight = false;
+	mainWatch = null;
+	preloadWatch = null;
+	outputDir = "";
+	logLevel;
+	clearScreen;
+	rendererOnly;
+	sourcemap;
+	outDirOverride;
+	configPaths = /* @__PURE__ */ new Set();
+	configDebounce = null;
+	onRestart = null;
+	rendererUrl = null;
+	constructor(configPath, opts) {
+		this.configPath = configPath;
+		this.logLevel = opts?.logLevel;
+		this.clearScreen = opts?.clearScreen;
+		this.rendererOnly = opts?.rendererOnly ?? false;
+		this.sourcemap = opts?.sourcemap;
+		this.outDirOverride = opts?.outDir;
+		if (this.logLevel) setLogLevel(this.logLevel);
+	}
+	async start() {
+		this.cleanedUp = false;
+		this.shuttingDown = false;
+		validateViteVersion(version);
+		const totalTimer = startTimer();
+		const loaded = await loadConfig(this.configPath);
+		this.config = loaded.config;
+		this.root = loaded.root;
+		this.outputDir = this.outDirOverride ? resolve(this.root, this.outDirOverride) : resolve(this.root, ".electro");
+		this.configPaths.add(loaded.configPath);
+		for (const win of this.config.windows ?? []) this.configPaths.add(win.__source);
+		const windows = this.config.windows ?? [];
+		const srcDir = resolve(this.root, "src");
+		const mainEntry = resolve(dirname(this.config.runtime.__source), this.config.runtime.entry);
+		session({
+			root: this.root,
+			main: mainEntry,
+			preload: windows.length > 0 ? resolve(this.outputDir, "generated/preload") : null,
+			renderer: windows.length > 0 ? resolve(this.root, dirname(relative(this.root, windows[0].__source))) : null,
+			windows: windows.map((w) => ({
+				name: w.name,
+				entry: resolve(dirname(w.__source), w.entry)
+			}))
+		});
+		const codegenTimer = startTimer();
+		try {
+			await this.runCodegen(this.outputDir, srcDir);
+			step("codegen", codegenTimer());
+		} catch (err) {
+			stepFail("codegen", err instanceof Error ? err.message : String(err));
+			throw err;
+		}
+		if (windows.length > 0) {
+			const rendererTimer = startTimer();
+			try {
+				await this.startRenderer();
+				step("renderer", rendererTimer());
+			} catch (err) {
+				stepFail("renderer", err instanceof Error ? err.message : String(err));
+				throw err;
+			}
+		}
+		if (this.rendererOnly) {
+			note("Renderer-only mode — skipping main, preload, Electron");
+			footer(`Ready in ${totalTimer()}`, this.rendererUrl ?? void 0);
+			this.attachConfigWatcher();
+			return;
+		}
+		const externals = await resolveExternals(this.root);
+		if (windows.length > 0) {
+			const preloadTimer = startTimer();
+			try {
+				await this.buildPreload(externals);
+				step("preload", preloadTimer());
+			} catch (err) {
+				stepFail("preload", err instanceof Error ? err.message : String(err));
+				throw err;
+			}
+		}
+		const mainBuildTimer = startTimer();
+		try {
+			await this.buildMain(externals);
+			step("main", mainBuildTimer());
+		} catch (err) {
+			stepFail("main", err instanceof Error ? err.message : String(err));
+			throw err;
+		}
+		const electronTimer = startTimer();
+		try {
+			await this.attachElectronProcess();
+			step("electron", electronTimer());
+		} catch (err) {
+			stepFail("electron", err instanceof Error ? err.message : String(err));
+			throw err;
+		}
+		footer(`Ready in ${totalTimer()}`, this.rendererUrl ?? void 0);
+		this.attachConfigWatcher();
+	}
+	/** Register a callback for config-triggered restarts. */
+	setOnRestart(fn) {
+		this.onRestart = fn;
+	}
+	/** Clean shutdown — idempotent, safe to call from any context. */
+	stop() {
+		if (this.cleanedUp) return;
+		this.cleanedUp = true;
+		this.shuttingDown = true;
+		if (this.configDebounce) {
+			clearTimeout(this.configDebounce);
+			this.configDebounce = null;
+		}
+		if (this.rendererServer?.watcher) for (const configPath of this.configPaths) this.rendererServer.watcher.unwatch(configPath);
+		this.configPaths.clear();
+		this.mainWatch?.close();
+		this.mainWatch = null;
+		this.preloadWatch?.close();
+		this.preloadWatch = null;
+		if (this.mainRestartFlushTimer) {
+			clearTimeout(this.mainRestartFlushTimer);
+			this.mainRestartFlushTimer = null;
+		}
+		if (this.rendererServer) {
+			this.rendererServer.close();
+			this.rendererServer = null;
+		}
+		if (this.electronProcess) {
+			const proc = this.electronProcess;
+			this.electronProcess = null;
+			proc.kill();
+		}
+	}
+	async runCodegen(outputDir, srcDir) {
+		const scanResult = await scan(srcDir);
+		this.lastScanResult = scanResult;
+		const { files, envTypes } = generate({
+			scanResult,
+			windows: this.config.windows ?? [],
+			outputDir,
+			srcDir
+		});
+		await mkdir(outputDir, { recursive: true });
+		for (const file of files) {
+			const filePath = resolve(outputDir, file.path);
+			await mkdir(dirname(filePath), { recursive: true });
+			await writeFile(filePath, file.content);
+		}
+		const envTypesPath = resolve(srcDir, envTypes.path);
+		await mkdir(dirname(envTypesPath), { recursive: true });
+		await writeFile(envTypesPath, envTypes.content);
+	}
+	async startRenderer() {
+		const windows = this.config.windows ?? [];
+		const userViteConfigs = windows.filter((w) => w.vite).map((w) => w.vite);
+		this.rendererServer = await createServer(createRendererConfig({
+			root: this.root,
+			windows,
+			userViteConfigs: userViteConfigs.length > 0 ? userViteConfigs : void 0,
+			logLevel: this.logLevel,
+			clearScreen: this.clearScreen
+		}));
+		patchLogger(this.rendererServer.config.logger, "renderer");
+		await this.rendererServer.listen();
+		const addr = this.rendererServer.httpServer?.address();
+		this.rendererUrl = `http://localhost:${typeof addr === "object" && addr ? addr.port : 5173}`;
+	}
+	async buildPreload(externals) {
+		const windows = this.config.windows ?? [];
+		const preloadOutDir = resolve(this.outputDir, "preload");
+		const input = {};
+		for (const win of windows) input[win.name] = resolve(this.outputDir, `generated/preload/${win.name}.gen.ts`);
+		const firstEntry = Object.values(input)[0];
+		const baseConfig = createNodeConfig({
+			scope: "preload",
+			root: this.root,
+			entry: firstEntry,
+			externals,
+			outDir: preloadOutDir,
+			watch: true,
+			plugins: [
+				assetPlugin(),
+				workerPlugin(),
+				modulePathPlugin()
+			],
+			logLevel: this.logLevel,
+			clearScreen: this.clearScreen,
+			sourcemap: this.sourcemap
+		});
+		if (Object.keys(input).length > 1) {
+			const subBuildConfig = createNodeConfig({
+				scope: "preload",
+				root: this.root,
+				entry: firstEntry,
+				externals,
+				outDir: preloadOutDir,
+				watch: false,
+				plugins: [
+					assetPlugin(),
+					workerPlugin(),
+					modulePathPlugin()
+				],
+				logLevel: this.logLevel,
+				clearScreen: this.clearScreen,
+				sourcemap: this.sourcemap
+			});
+			baseConfig.plugins.push(isolateEntriesPlugin(subBuildConfig));
+		}
+		if (baseConfig.build) baseConfig.build.rolldownOptions = {
+			...baseConfig.build.rolldownOptions,
+			input
+		};
+		let firstBuild = true;
+		const self = this;
+		baseConfig.plugins.push({
+			name: "electro:preload-watch",
+			apply: "build",
+			watchChange(id) {
+				if (!firstBuild) runtimeLog("preload", "rebuild → page reload", relative(self.root, id));
+			},
+			closeBundle() {
+				if (firstBuild) {
+					firstBuild = false;
+					return;
+				}
+				if (self.rendererServer) self.rendererServer.ws.send({ type: "full-reload" });
+			}
+		});
+		this.preloadWatch = await build(baseConfig);
+	}
+	async buildMain(externals) {
+		const runtimeEntry = this.config.runtime.entry;
+		const entry = resolve(dirname(this.config.runtime.__source), runtimeEntry);
+		const windowDefs = (this.config.windows ?? []).map((w) => ({
+			name: w.name,
+			type: w.type,
+			lifecycle: w.lifecycle,
+			autoShow: w.autoShow,
+			behavior: w.behavior,
+			window: w.window
+		}));
+		const mainConfig = createNodeConfig({
+			scope: "main",
+			root: this.root,
+			entry,
+			externals,
+			outDir: resolve(this.outputDir, "main"),
+			watch: true,
+			plugins: [
+				assetPlugin(),
+				workerPlugin(),
+				modulePathPlugin()
+			],
+			logLevel: this.logLevel,
+			clearScreen: this.clearScreen,
+			userViteConfig: this.config.runtime.vite,
+			sourcemap: this.sourcemap,
+			define: { __ELECTRO_WINDOW_DEFINITIONS__: JSON.stringify(windowDefs) }
+		});
+		const self = this;
+		let firstBuild = true;
+		let changedFile = null;
+		mainConfig.plugins.push({
+			name: "electro:main-watch",
+			apply: "build",
+			watchChange(id) {
+				changedFile = changedFile ?? id;
+			},
+			async closeBundle() {
+				if (firstBuild) {
+					firstBuild = false;
+					changedFile = null;
+					return;
+				}
+				const currentChanged = changedFile;
+				changedFile = null;
+				const srcDir = resolve(self.root, "src");
+				const newScan = await scan(srcDir);
+				if (JSON.stringify(newScan) !== JSON.stringify(self.lastScanResult)) {
+					runtimeLog("main", "generated");
+					await self.runCodegen(self.outputDir, srcDir);
+				}
+				self.queueMainRestart(currentChanged);
+			}
+		});
+		this.mainWatch = await build(mainConfig);
+	}
+	async attachElectronProcess() {
+		const mainEntry = resolve(this.outputDir, "main/index.mjs");
+		const env = { ELECTRO_DEV: "true" };
+		if (this.rendererServer) {
+			const addr = this.rendererServer.httpServer?.address();
+			const port = typeof addr === "object" && addr ? addr.port : 5173;
+			env.ELECTRO_RENDERER_BASE = `http://localhost:${port}`;
+			for (const win of this.config.windows ?? []) {
+				const entryPath = resolve(dirname(win.__source), win.entry);
+				const relPath = relative(this.root, entryPath);
+				env[`ELECTRO_DEV_URL_${win.name}`] = `http://localhost:${port}/${relPath}`;
+			}
+		}
+		const proc = await launchElectron({
+			root: this.root,
+			entry: mainEntry,
+			env
+		});
+		this.electronProcess = proc;
+		proc.exited.then((code) => {
+			if (this.electronProcess !== proc) return;
+			if (this.shuttingDown) return;
+			if (code === 0) runtimeLog("main", "exited");
+			else runtimeLog("main", `crashed (exit ${code})`);
+			this.stop();
+			process.exit(code === 0 ? 0 : 1);
+		});
+	}
+	/**
+	* Restart Electron — handles queued restarts if another rebuild
+	* arrives while restart is in flight.
+	*/
+	async restartElectron(changedFile) {
+		if (this.restartInFlight) {
+			this.restartQueued = true;
+			this.restartQueuedFile = changedFile ?? this.restartQueuedFile;
+			return;
+		}
+		this.restartInFlight = true;
+		let nextChanged = changedFile;
+		do {
+			this.restartQueued = false;
+			runtimeLog("main", "rebuild → restart", nextChanged ? relative(this.root, nextChanged) : null);
+			nextChanged = null;
+			if (this.electronProcess) {
+				const prev = this.electronProcess;
+				this.electronProcess = null;
+				prev.kill();
+				await prev.exited;
+			}
+			await this.attachElectronProcess();
+			if (this.restartQueued) {
+				nextChanged = this.restartQueuedFile;
+				this.restartQueuedFile = null;
+			}
+		} while (this.restartQueued);
+		this.restartInFlight = false;
+	}
+	queueMainRestart(changedFile) {
+		if (changedFile) this.mainRestartReason = changedFile;
+		else if (!this.mainRestartReason) this.mainRestartReason = changedFile;
+		this.mainRestartQueued = true;
+		this.scheduleMainRestartFlush();
+	}
+	scheduleMainRestartFlush() {
+		if (this.mainRestartFlushTimer) clearTimeout(this.mainRestartFlushTimer);
+		this.mainRestartFlushTimer = setTimeout(() => {
+			this.mainRestartFlushTimer = null;
+			this.flushMainRestartQueue();
+		}, MAIN_RESTART_DEBOUNCE_MS);
+	}
+	async flushMainRestartQueue() {
+		if (this.mainRestartFlushInFlight || !this.mainRestartQueued) return;
+		this.mainRestartFlushInFlight = true;
+		try {
+			const reason = this.mainRestartReason;
+			this.mainRestartQueued = false;
+			this.mainRestartReason = null;
+			await this.restartElectron(reason);
+		} finally {
+			this.mainRestartFlushInFlight = false;
+			if (this.mainRestartQueued && !this.mainRestartFlushTimer) this.scheduleMainRestartFlush();
+		}
+	}
+	attachConfigWatcher() {
+		if (!this.rendererServer?.watcher) return;
+		const watcher = this.rendererServer.watcher;
+		for (const configPath of this.configPaths) watcher.add(configPath);
+		watcher.on("change", (changedPath) => {
+			if (!this.configPaths.has(changedPath)) return;
+			if (this.shuttingDown) return;
+			if (this.configDebounce) clearTimeout(this.configDebounce);
+			this.configDebounce = setTimeout(() => {
+				this.configDebounce = null;
+				info("Config file changed, restarting...");
+				this.stop();
+				this.onRestart?.();
+			}, CONFIG_DEBOUNCE_MS);
+		});
+	}
+};
+//#endregion
+//#region src/commands/dev.ts
+async function dev(options) {
+	if (options.sourcemap) validateSourcemap(options.sourcemap);
+	const createServer = () => new DevServer(options.config, {
+		logLevel: options.logLevel,
+		clearScreen: options.clearScreen,
+		rendererOnly: options.rendererOnly,
+		sourcemap: options.sourcemap,
+		outDir: options.outDir
+	});
+	let server = createServer();
+	const shutdown = () => {
+		server.stop();
+		process.exit(0);
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+	const startWithRestart = async () => {
+		server.setOnRestart(() => {
+			server = createServer();
+			startWithRestart();
+		});
+		try {
+			await server.start();
+		} catch (err) {
+			error(`Failed to start dev server: ${err instanceof Error ? err.message : String(err)}`);
+			server.stop();
+			process.exit(1);
+		}
+	};
+	await startWithRestart();
+	await new Promise(() => {});
+}
+//#endregion
+//#region src/commands/generate.ts
+async function generate$1(options) {
+	const configPath = resolve(process.cwd(), options.config);
+	const outputDir = resolve(process.cwd(), options.output);
+	const config = (await import(configPath)).default;
+	if (!config) {
+		console.error("Error: electro.config.ts must have a default export");
+		process.exit(1);
+	}
+	const windows = config.windows ?? [];
+	console.log(`Loaded config with ${windows.length} window(s)`);
+	const srcDir = resolve(process.cwd(), "src");
+	console.log(`Scanning ${srcDir}...`);
+	const scanResult = await scan(srcDir);
+	console.log(`Found ${scanResult.features.length} feature(s)`);
+	const { files, envTypes } = generate({
+		scanResult,
+		windows,
+		outputDir,
+		srcDir
+	});
+	console.log(`Generating ${files.length + 1} file(s)...`);
+	for (const file of files) {
+		const fullPath = resolve(outputDir, file.path);
+		await mkdir(dirname(fullPath), { recursive: true });
+		await writeFile(fullPath, file.content);
+		console.log(`  .electro/${file.path}`);
+	}
+	const envTypesPath = resolve(srcDir, envTypes.path);
+	await mkdir(dirname(envTypesPath), { recursive: true });
+	await writeFile(envTypesPath, envTypes.content);
+	console.log(`  src/${envTypes.path}`);
+	console.log("Done.");
+}
+//#endregion
+//#region src/commands/preview.ts
+async function preview(options) {
+	if (options.sourcemap) validateSourcemap(options.sourcemap);
+	if (options.logLevel) setLogLevel(options.logLevel);
+	const totalTimer = startTimer();
+	if (!options.skipBuild) await build$1(options);
+	else note("Skipped build (--skip-build)");
+	const root = process.cwd();
+	const mainEntry = resolve(resolve(root, options.outDir), "main/index.mjs");
+	const launchTimer = startTimer();
+	try {
+		const proc = await launchElectron({
+			root,
+			entry: mainEntry
+		});
+		step("electron", launchTimer());
+		footer(`Preview ready in ${totalTimer()}`);
+		const onSignal = () => proc.kill();
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+		const code = await proc.exited ?? 0;
+		process.off("SIGINT", onSignal);
+		process.off("SIGTERM", onSignal);
+		if (code === 0) runtimeLog("main", "exited");
+		else {
+			runtimeLog("main", `crashed (exit ${code})`);
+			process.exit(1);
+		}
+	} catch (err) {
+		stepFail("electron", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/index.ts
+const cli = cac("electro");
+cli.command("generate", "Generate preload scripts, bridge types, and context types").option("-c, --config <path>", "Path to electro.config.ts", { default: "electro.config.ts" }).option("-o, --output <dir>", "Output directory", { default: ".electro" }).action(generate$1);
+cli.command("build", "Build for production").option("-c, --config <path>", "Path to electro.config.ts", { default: "electro.config.ts" }).option("-o, --outDir <dir>", "Output directory", { default: "dist" }).option("--sourcemap <mode>", "Sourcemap mode (linked | inline | external | none)").option("--minify", "Minify output (default: true)", { default: true }).option("--no-minify", "Disable minification").option("--bytecode", "Compile main/preload to V8 bytecode for source protection").option("-l, --logLevel <level>", "Log level (info | warn | error | silent)").action(build$1);
+cli.command("preview", "Build and preview in Electron").option("-c, --config <path>", "Path to electro.config.ts", { default: "electro.config.ts" }).option("-o, --outDir <dir>", "Output directory", { default: "dist" }).option("--sourcemap <mode>", "Sourcemap mode (linked | inline | external | none)").option("--minify", "Minify output (default: true)", { default: true }).option("--no-minify", "Disable minification").option("--bytecode", "Compile main/preload to V8 bytecode for source protection").option("--skip-build", "Skip build step and launch from existing output").option("-l, --logLevel <level>", "Log level (info | warn | error | silent)").action(preview);
+cli.command("dev", "Start development server with Electron").option("-c, --config <path>", "Path to electro.config.ts", { default: "electro.config.ts" }).option("--clearScreen", "Clear screen on rebuild", { default: true }).option("-l, --logLevel <level>", "Log level (info | warn | error | silent)").option("--renderer-only", "Start only the renderer dev server (no Electron)").option("--sourcemap <mode>", "Sourcemap mode (linked | inline | external | none)").option("--outDir <dir>", "Output directory override (default: .electro)").action(dev);
+cli.help();
+cli.version(version$1);
+cli.parse();
+//#endregion
+export {  };