muon-ui 0.7.0 → 0.9.0

package/dist/{vite-options-FFh0NWUa.cjs → vite-internals-HXgH7b5M.cjs}

@@ -1,11 +1,11 @@
 /*!
 * name: muon-ui
-* version: 0.7.0
+* version: 0.9.0
 * description: A multi-platform GUI application framework that uses CEF as its backend
 * author: Kouji Matsui (@kekyo@mi.kekyo.net)
 * license: MIT
 * repository.url: https://github.com/kekyo/muon-ui.git
-* git.commit.hash: fe80718aaa617c0c0ea5c816bbe38d22bf2e8402
+* git.commit.hash: 3437b522a51d8772713b72722b109c5ff30fc711
 */
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -39,6 +39,8 @@ let node_crypto = require("node:crypto");
 let node_os = require("node:os");
 let adm_zip = require("adm-zip");
 adm_zip = __toESM(adm_zip, 1);
+let sharp = require("sharp");
+sharp = __toESM(sharp, 1);
 //#region src/targets.ts
 /**
 * Supported public Muon targets in deterministic build order.
@@ -56,7 +58,7 @@ var targetDescriptors = {
 		cefTarget: "linux64",
 		os: "linux",
 		arch: "amd64",
-		distributionDirectoryName: "dist-muon-linux-amd64",
+		distributionDirectoryName: "dist-muon/linux-amd64",
 		runtimeExecutableName: "muon-core",
 		bootstrapExecutableName: "muon-bootstrap",
 		launcherExtension: "",
@@ -71,7 +73,7 @@ var targetDescriptors = {
 		cefTarget: "linuxarm",
 		os: "linux",
 		arch: "armhf",
-		distributionDirectoryName: "dist-muon-linux-armhf",
+		distributionDirectoryName: "dist-muon/linux-armhf",
 		runtimeExecutableName: "muon-core",
 		bootstrapExecutableName: "muon-bootstrap",
 		launcherExtension: "",
@@ -86,7 +88,7 @@ var targetDescriptors = {
 		cefTarget: "linuxarm64",
 		os: "linux",
 		arch: "arm64",
-		distributionDirectoryName: "dist-muon-linux-arm64",
+		distributionDirectoryName: "dist-muon/linux-arm64",
 		runtimeExecutableName: "muon-core",
 		bootstrapExecutableName: "muon-bootstrap",
 		launcherExtension: "",
@@ -101,7 +103,7 @@ var targetDescriptors = {
 		cefTarget: "windows32",
 		os: "windows",
 		arch: "i686",
-		distributionDirectoryName: "dist-muon-windows-i686",
+		distributionDirectoryName: "dist-muon/windows-i686",
 		runtimeExecutableName: "muon-core.exe",
 		bootstrapExecutableName: "muon-bootstrap.exe",
 		launcherExtension: ".exe",
@@ -121,7 +123,7 @@ var targetDescriptors = {
 		cefTarget: "windows64",
 		os: "windows",
 		arch: "amd64",
-		distributionDirectoryName: "dist-muon-windows-amd64",
+		distributionDirectoryName: "dist-muon/windows-amd64",
 		runtimeExecutableName: "muon-core.exe",
 		bootstrapExecutableName: "muon-bootstrap.exe",
 		launcherExtension: ".exe",
@@ -146,6 +148,20 @@ Object.fromEntries(allMuonTargets.map((target) => [targetDescriptors[target].cef
 */
 var getMuonTargetDescriptor = (target) => targetDescriptors[target];
 /**
+* Returns the runtime app identifier embedded for one target distribution.
+*
+* @param appId Base sanitized application identifier.
+* @param target Public Muon target.
+* @returns Target runtime application identifier.
+*
+* @remarks Windows targets append their public architecture name so 32-bit and
+* 64-bit packages do not share runtime state or installer identities.
+*/
+var getMuonTargetRuntimeAppId = (appId, target) => {
+	const descriptor = getMuonTargetDescriptor(target);
+	return descriptor.os === "windows" ? `${appId}.${descriptor.arch}` : appId;
+};
+/**
 * Normalizes a user supplied public Muon target.
 *
 * @param target Target value supplied by the user.
@@ -192,8 +208,8 @@ var getDefaultMuonPrepareTarget = (platform, architecture) => {
 		throw new Error(`Unsupported Muon prepare target: platform=${platform}, arch=${architecture}`);
 	}
 };
-var getPrepareExecutableName = (platform) => platform === "win32" ? "muon-prepare.exe" : "muon-prepare";
-var moduleDirectory$2 = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
+var getBuilderExecutableName = (platform) => platform === "win32" ? "muon-builder.exe" : "muon-builder";
+var moduleDirectory$4 = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
 var canExecute = async (path) => {
 	try {
 		await (0, node_fs_promises.access)(path, node_fs.constants.X_OK);
@@ -202,12 +218,12 @@ var canExecute = async (path) => {
 		return false;
 	}
 };
-var resolveMuonPrepareExecutable = async (options) => {
-	const explicit = options.prepareExecutablePath ?? options.environment.MUON_PREPARE_PATH;
+var resolveMuonBuilderExecutable = async (options) => {
+	const explicit = options.prepareExecutablePath ?? options.environment.MUON_BUILDER_PATH;
 	if (explicit !== void 0 && explicit !== "") return explicit;
-	const executableName = getPrepareExecutableName(process.platform);
+	const executableName = getBuilderExecutableName(process.platform);
 	const target = getDefaultMuonPrepareTarget(process.platform, process.arch);
-	const candidates = [(0, node_path.join)(moduleDirectory$2, "native", target, executableName), (0, node_path.join)(moduleDirectory$2, "..", "dist", "native", target, executableName)];
+	const candidates = [(0, node_path.join)(moduleDirectory$4, "native", target, executableName), (0, node_path.join)(moduleDirectory$4, "..", "dist", "native", target, executableName)];
 	for (const candidate of candidates) if (await canExecute(candidate)) return candidate;
 	return candidates[0] ?? executableName;
 };
@@ -226,14 +242,100 @@ var createMuonPrepareArguments = (options) => {
 	if (options.quiet) args.push("--quiet");
 	return args;
 };
-/**
-* Invokes the native muon-prepare executable and returns the prepared runtime.
-*
-* @param options Native prepare invocation options.
-* @returns Prepared runtime location.
-*/
-var runMuonPrepare = async (options) => {
-	const child = (0, node_child_process.spawn)(await resolveMuonPrepareExecutable(options), createMuonPrepareArguments(options), {
+var spinnerFrames = [
+	"-",
+	"\\",
+	"|",
+	"/"
+];
+var spinnerIntervalMilliseconds = 100;
+var terminalLineStart = "\r";
+var terminalClearLine = "\x1B[K";
+var isMuonPrepareStatusLine = (line) => {
+	const trimmed = line.trimEnd();
+	return trimmed.endsWith("...") || trimmed === "Failed to prepare CEF." || trimmed.startsWith("Downloading CEF binary:");
+};
+var shouldKeepMuonPrepareStatusAfterLine = (line) => line.startsWith("Muon files copied to staging:");
+var createPlainStderrForwarder = () => ({
+	write: (chunk) => {
+		process.stderr.write(chunk);
+	},
+	flush: () => {}
+});
+var createSpinnerStderrForwarder = () => {
+	let pending = "";
+	let activeStatus = void 0;
+	let frameIndex = 0;
+	let timer = void 0;
+	const writeRaw = (chunk) => {
+		process.stderr.write(chunk);
+	};
+	const stopTimer = () => {
+		if (timer !== void 0) {
+			clearInterval(timer);
+			timer = void 0;
+		}
+	};
+	const renderStatus = () => {
+		if (activeStatus === void 0) return;
+		writeRaw(`${terminalLineStart}${spinnerFrames[frameIndex] ?? spinnerFrames[0]} ${activeStatus}${terminalClearLine}`);
+		frameIndex = (frameIndex + 1) % spinnerFrames.length;
+	};
+	const ensureTimer = () => {
+		if (timer === void 0) timer = setInterval(renderStatus, spinnerIntervalMilliseconds);
+	};
+	const finishStatus = () => {
+		if (activeStatus === void 0) return;
+		const status = activeStatus;
+		activeStatus = void 0;
+		stopTimer();
+		frameIndex = 0;
+		writeRaw(`${terminalLineStart}${status}${terminalClearLine}\n`);
+	};
+	const startStatus = (status) => {
+		if (activeStatus !== void 0 && activeStatus !== status) finishStatus();
+		activeStatus = status;
+		renderStatus();
+		ensureTimer();
+	};
+	const writeLine = (line) => {
+		const text = line.replace(/\r?\n$/, "");
+		if (isMuonPrepareStatusLine(text)) {
+			startStatus(text.trimEnd());
+			return;
+		}
+		if (activeStatus !== void 0 && shouldKeepMuonPrepareStatusAfterLine(text)) {
+			writeRaw(`${terminalLineStart}${terminalClearLine}${line.endsWith("\n") ? line : `${line}\n`}`);
+			renderStatus();
+			return;
+		}
+		finishStatus();
+		writeRaw(line);
+	};
+	return {
+		write: (chunk) => {
+			pending += chunk;
+			for (;;) {
+				const newlineIndex = pending.indexOf("\n");
+				if (newlineIndex < 0) break;
+				const line = pending.slice(0, newlineIndex + 1);
+				pending = pending.slice(newlineIndex + 1);
+				writeLine(line);
+			}
+		},
+		flush: () => {
+			if (pending.length > 0) {
+				const line = pending;
+				pending = "";
+				writeLine(line);
+			}
+			finishStatus();
+		}
+	};
+};
+var createMuonPrepareStderrForwarder = () => process.stderr.isTTY === true ? createSpinnerStderrForwarder() : createPlainStderrForwarder();
+var runMuonPrepareCommand = async (options) => {
+	const child = (0, node_child_process.spawn)(await resolveMuonBuilderExecutable(options), [...options.args], {
 		cwd: options.cwd,
 		env: options.environment,
 		stdio: [
@@ -246,22 +348,46 @@ var runMuonPrepare = async (options) => {
 	let stderr = "";
 	child.stdout.setEncoding("utf8");
 	child.stderr.setEncoding("utf8");
+	const stderrForwarder = options.quiet ? void 0 : createMuonPrepareStderrForwarder();
 	child.stdout.on("data", (chunk) => {
 		stdout += chunk;
 	});
 	child.stderr.on("data", (chunk) => {
 		stderr += chunk;
-		if (!options.quiet) process.stderr.write(chunk);
+		stderrForwarder?.write(chunk);
 	});
-	const exitCode = await new Promise((resolvePromise, reject) => {
-		child.on("error", reject);
-		child.on("close", (code) => {
-			resolvePromise(code ?? 1);
-		});
+	const exitCode = await (async () => {
+		try {
+			return await new Promise((resolvePromise, reject) => {
+				child.on("error", reject);
+				child.on("close", (code) => {
+					resolvePromise(code ?? 1);
+				});
+			});
+		} finally {
+			stderrForwarder?.flush();
+		}
+	})();
+	if (exitCode !== 0) throw new Error(`muon-builder failed with exit code ${exitCode}.\n${stderr.trim()}`);
+	return stdout;
+};
+/**
+* Invokes the native muon-builder executable and returns the prepared runtime.
+*
+* @param options Native prepare invocation options.
+* @returns Prepared runtime location.
+*/
+var runMuonPrepare = async (options) => {
+	const args = createMuonPrepareArguments(options);
+	const stdout = await runMuonPrepareCommand({
+		prepareExecutablePath: options.prepareExecutablePath,
+		environment: options.environment,
+		cwd: options.cwd,
+		quiet: options.quiet,
+		args
 	});
-	if (exitCode !== 0) throw new Error(`muon-prepare failed with exit code ${exitCode}.\n${stderr.trim()}`);
 	const result = JSON.parse(stdout);
-	if (result.stagePath !== void 0 && typeof result.stagePath !== "string" || typeof result.muonPath !== "string" || typeof result.cefPath !== "string" || typeof result.cacheHit !== "boolean") throw new Error(`muon-prepare returned invalid JSON: ${stdout}`);
+	if (result.stagePath !== void 0 && typeof result.stagePath !== "string" || typeof result.muonPath !== "string" || typeof result.cefPath !== "string" || typeof result.cacheHit !== "boolean") throw new Error(`muon-builder returned invalid JSON: ${stdout}`);
 	return {
 		...result.stagePath === void 0 ? {} : { stagePath: result.stagePath },
 		muonPath: result.muonPath,
@@ -269,11 +395,34 @@ var runMuonPrepare = async (options) => {
 		cacheHit: result.cacheHit
 	};
 };
+/**
+* Invokes the native muon-builder executable to write Windows PE resources.
+*
+* @param options Resource update invocation options.
+*/
+var runMuonPrepareResourceUpdate = async (options) => {
+	await runMuonPrepareCommand({
+		prepareExecutablePath: options.prepareExecutablePath,
+		environment: options.environment,
+		cwd: options.cwd,
+		quiet: options.quiet,
+		args: [
+			"resource",
+			"--input",
+			options.inputPath,
+			"--updates-json",
+			options.updatesJsonPath,
+			"--output",
+			options.outputPath,
+			...options.quiet ? ["--quiet"] : []
+		]
+	});
+};
 //#endregion
 //#region src/gitignore.ts
 var muonGitignoreEntries = [
 	".muon/",
-	"dist-muon-*/",
+	"dist-muon/",
 	"artifacts/"
 ];
 var muonGitignoreEntryAliases = {
@@ -283,11 +432,13 @@ var muonGitignoreEntryAliases = {
 		".muon",
 		"/.muon"
 	],
-	"dist-muon-*/": [
-		"dist-muon-*/",
-		"/dist-muon-*/",
-		"dist-muon-*",
-		"/dist-muon-*"
+	"dist-muon/": [
+		"dist-muon/",
+		"/dist-muon/",
+		"dist-muon",
+		"/dist-muon",
+		"dist-muon/*",
+		"/dist-muon/*"
 	],
 	"artifacts/": [
 		"artifacts/",
@@ -1602,8 +1753,10 @@ var encodeTaggedBytes = (tag, bytes) => Buffer.concat([
 	encodeVarUint(BigInt(bytes.length)),
 	Buffer.from(bytes)
 ]);
-var isJsonObject$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isJsonObject$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isPath = (path, first, second) => path.length === 2 && path[0] === first && path[1] === second;
+var isPluginSignaturePath = (path) => path.length === 3 && path[0] === "plugin" && path[1] === "plugins" && path[2] === "signature";
+var isPluginSaltPath = (path) => path.length === 3 && path[0] === "plugin" && path[1] === "plugins" && path[2] === "salt";
 var isHexString = (value) => value.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(value);
 var decodeHexString = (value) => {
 	const bytes = Buffer.alloc(value.length / 2);
@@ -1613,6 +1766,8 @@ var decodeHexString = (value) => {
 var encodeKnownBinaryString = (path, value) => {
 	if (isPath(path, "asset", "signature")) return value.length === 40 && isHexString(value) ? decodeHexString(value) : void 0;
 	if (isPath(path, "asset", "salt")) return isHexString(value) ? decodeHexString(value) : void 0;
+	if (isPluginSignaturePath(path)) return value.length === 40 && isHexString(value) ? decodeHexString(value) : void 0;
+	if (isPluginSaltPath(path)) return isHexString(value) ? decodeHexString(value) : void 0;
 	if (isPath(path, "browser", "backgroundColor")) {
 		const hex = value.startsWith("#") ? value.slice(1) : value;
 		return hex.length === 6 && isHexString(hex) ? decodeHexString(hex) : void 0;
@@ -1635,7 +1790,7 @@ var encodeTlvValue = (value, path) => {
 		encodeVarUint(BigInt(value.length)),
 		...value.map((entry) => encodeTlvValue(entry, path))
 	]);
-	if (isJsonObject$2(value)) {
+	if (isJsonObject$4(value)) {
 		const entries = Object.entries(value);
 		return Buffer.concat([
 			Buffer.from([tlvObjectTag]),
@@ -1660,8 +1815,8 @@ var encodeMuonConfigTlv = (config) => encodeTlvValue(config, []);
 */
 var createMuonEmbeddedConfigSlot = (payload = void 0) => {
 	if (payload !== void 0 && payload.length > muonEmbeddedConfigPayloadCapacity) throw new Error(`Encoded muon config exceeds the embedded slot capacity: ${payload.length} > ${muonEmbeddedConfigPayloadCapacity}`);
-	const slot = createEmptySlot();
-	if (payload === void 0) return slot;
+	if (payload === void 0) return createEmptySlot();
+	const slot = (0, node_crypto.randomBytes)(muonEmbeddedConfigSlotSize);
 	Buffer.from(payload).copy(slot, 0);
 	return slot;
 };
@@ -1673,9 +1828,12 @@ var createMuonEmbeddedConfigSlot = (payload = void 0) => {
 */
 var createMuonBootstrapEmbeddedConfigSlot = (payload = void 0) => {
 	if (payload !== void 0 && payload.length > muonBootstrapEmbeddedConfigPayloadCapacity) throw new Error(`Encoded muon config exceeds the embedded bootstrap slot capacity: ${payload.length} > ${muonBootstrapEmbeddedConfigPayloadCapacity}`);
-	const slot = Buffer.alloc(muonBootstrapEmbeddedConfigSlotSize, 0);
-	muonBootstrapEmbeddedConfigEmptySlotMarker.copy(slot, 0);
-	if (payload === void 0) return slot;
+	if (payload === void 0) {
+		const slot = Buffer.alloc(muonBootstrapEmbeddedConfigSlotSize, 0);
+		muonBootstrapEmbeddedConfigEmptySlotMarker.copy(slot, 0);
+		return slot;
+	}
+	const slot = (0, node_crypto.randomBytes)(muonBootstrapEmbeddedConfigSlotSize);
 	Buffer.from(payload).copy(slot, 0);
 	return slot;
 };
@@ -1749,7 +1907,7 @@ var findMuonBootstrapEmbeddedConfigSlot = (content) => {
 	if (candidate === void 0) throw new Error("Embedded muon-bootstrap config slot was not found.");
 	return candidate;
 };
-var fileExists$2 = async (path) => {
+var fileExists$5 = async (path) => {
 	try {
 		return (await (0, node_fs_promises.stat)(path)).isFile();
 	} catch {
@@ -1765,10 +1923,10 @@ var resolveMuonConfigInputPath = async (configPath) => {
 			"muon.json"
 		]) {
 			const candidate = (0, node_path.join)(directory, fileName);
-			if (await fileExists$2(candidate)) return candidate;
+			if (await fileExists$5(candidate)) return candidate;
 		}
 	}
-	if (!await fileExists$2(configPath)) throw new Error(`muon config does not exist: ${configPath}`);
+	if (!await fileExists$5(configPath)) throw new Error(`muon config does not exist: ${configPath}`);
 	return configPath;
 };
 var readMuonConfigInput = async (configPath) => {
@@ -1864,6 +2022,831 @@ var embedMuonConfigInRuntime = async ({ runtimePath, configPath, outputRuntimePa
 	});
 };
 //#endregion
+//#region src/windows-icon.ts
+var sharp$1 = __resolveDefaultExport$1(sharp, true);
+globalThis.__screwUpIsInCJS_27e672935538 = true;
+function __resolveDefaultExport$1(module, isESM) {
+	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_27e672935538 === true;
+	const maybe = module;
+	const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
+	const unwrapNamespaceDefault = (value) => {
+		if (!value || typeof value !== "object") return value;
+		const inner = value;
+		if ((inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module") && "default" in inner) return inner.default;
+		return value;
+	};
+	const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
+	if (__isInCJS) return hasDefault ? resolvedDefault ?? module : module;
+	if (isESM) {
+		if (hasDefault) return resolvedDefault;
+		throw new Error("Default export not found.");
+	}
+	return hasDefault ? resolvedDefault ?? module : module;
+}
+var normalizedIconSize = 256;
+var windowsIconDibSizes = [
+	16,
+	24,
+	32,
+	48,
+	64,
+	128
+];
+var pngSignature = Buffer.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+/**
+* Creates a normalized square PNG icon image.
+*
+* @param pngData Source PNG bytes.
+* @param source Diagnostic source label used in errors.
+* @param label User-facing diagnostic label.
+* @returns PNG bytes normalized to the Muon base icon size.
+* @remarks Non-square images are fitted into transparent padding without
+* stretching. The normalized PNG is the source for all platform-specific icon
+* derivatives.
+*/
+var createNormalizedIconPngData = async (pngData, source, label) => {
+	await assertPngData(pngData, source, label);
+	try {
+		return await sharp$1(pngData).resize(normalizedIconSize, normalizedIconSize, {
+			fit: "contain",
+			background: {
+				r: 0,
+				g: 0,
+				b: 0,
+				alpha: 0
+			}
+		}).ensureAlpha().png().toBuffer();
+	} catch {
+		throw new Error(`${label} must be a valid PNG: ${source}`);
+	}
+};
+/**
+* Creates a normalized square PNG icon image for Windows resources.
+*
+* @param pngData Source PNG bytes.
+* @param source Diagnostic source label used in errors.
+* @returns PNG bytes normalized to the Muon base icon size.
+*/
+var createNormalizedMuonIconPngData = async (pngData, source) => await createNormalizedIconPngData(pngData, source, "Windows resource icon");
+/**
+* Creates a Windows ICO file from PNG bytes.
+*
+* @param pngData Source PNG bytes.
+* @param source Diagnostic source label used in errors.
+* @returns ICO file bytes containing 16, 24, 32, 48, 64, 128, and 256 pixel images.
+* @remarks The 256px entry is PNG-compressed. Smaller entries are 32-bit DIB
+* images, matching the common Windows ICO layout recommended by Microsoft.
+*/
+var createWindowsIconBufferFromPngData = async (pngData, source) => {
+	const normalizedPng = await createNormalizedMuonIconPngData(pngData, source);
+	const images = [];
+	for (const size of windowsIconDibSizes) {
+		const rawImage = await resizePngToRawRgba(normalizedPng, size, source);
+		images.push({
+			data: createDibIconImage(rawImage),
+			size,
+			bitCount: 32
+		});
+	}
+	images.push({
+		data: normalizedPng,
+		size: normalizedIconSize,
+		bitCount: 32
+	});
+	return createIco(images);
+};
+/**
+* Creates a Windows ICO file from a PNG file.
+*
+* @param sourcePath Source PNG file path.
+* @param outputPath Output ICO file path.
+* @returns Promise resolved when the ICO file has been written.
+*/
+var createWindowsIconFromPngFile = async (sourcePath, outputPath) => {
+	const icon = await createWindowsIconBufferFromPngData(await (0, node_fs_promises.readFile)(sourcePath), sourcePath);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(outputPath, icon);
+};
+var assertPngData = async (data, source, label) => {
+	if (data.length === 0) throw new Error(`${label} PNG must not be empty: ${source}`);
+	if (!data.subarray(0, pngSignature.length).equals(pngSignature)) throw new Error(`${label} must be a valid PNG: ${source}`);
+	try {
+		if ((await sharp$1(data).metadata()).format !== "png") throw new Error();
+	} catch {
+		throw new Error(`${label} must be a valid PNG: ${source}`);
+	}
+};
+var resizePngToRawRgba = async (pngData, size, source) => {
+	try {
+		const { data, info } = await sharp$1(pngData).resize(size, size, {
+			fit: "fill",
+			kernel: "lanczos3"
+		}).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+		if (info.width !== size || info.height !== size || info.channels !== 4) throw new Error();
+		return {
+			data,
+			width: info.width,
+			height: info.height
+		};
+	} catch {
+		throw new Error(`Failed to resize Windows resource icon PNG: ${source}`);
+	}
+};
+var createDibIconImage = (image) => {
+	const pixelBytes = image.width * image.height * 4;
+	const maskBytes = Math.ceil(image.width / 32) * 4 * image.height;
+	const output = Buffer.alloc(40 + pixelBytes + maskBytes);
+	output.writeUInt32LE(40, 0);
+	output.writeInt32LE(image.width, 4);
+	output.writeInt32LE(image.height * 2, 8);
+	output.writeUInt16LE(1, 12);
+	output.writeUInt16LE(32, 14);
+	output.writeUInt32LE(0, 16);
+	output.writeUInt32LE(pixelBytes + maskBytes, 20);
+	output.writeInt32LE(0, 24);
+	output.writeInt32LE(0, 28);
+	output.writeUInt32LE(0, 32);
+	output.writeUInt32LE(0, 36);
+	for (let y = 0; y < image.height; y += 1) {
+		const sourceY = image.height - 1 - y;
+		for (let x = 0; x < image.width; x += 1) {
+			const sourceOffset = (sourceY * image.width + x) * 4;
+			const outputOffset = 40 + (y * image.width + x) * 4;
+			output[outputOffset] = image.data[sourceOffset + 2];
+			output[outputOffset + 1] = image.data[sourceOffset + 1];
+			output[outputOffset + 2] = image.data[sourceOffset];
+			output[outputOffset + 3] = image.data[sourceOffset + 3];
+		}
+	}
+	return output;
+};
+var createIco = (images) => {
+	const directorySize = 6 + images.length * 16;
+	let imageOffset = directorySize;
+	const header = Buffer.alloc(directorySize);
+	header.writeUInt16LE(0, 0);
+	header.writeUInt16LE(1, 2);
+	header.writeUInt16LE(images.length, 4);
+	const imageData = [];
+	images.forEach((image, index) => {
+		const entryOffset = 6 + index * 16;
+		header[entryOffset] = image.size === 256 ? 0 : image.size;
+		header[entryOffset + 1] = image.size === 256 ? 0 : image.size;
+		header[entryOffset + 2] = 0;
+		header[entryOffset + 3] = 0;
+		header.writeUInt16LE(1, entryOffset + 4);
+		header.writeUInt16LE(image.bitCount, entryOffset + 6);
+		header.writeUInt32LE(image.data.length, entryOffset + 8);
+		header.writeUInt32LE(imageOffset, entryOffset + 12);
+		imageOffset += image.data.length;
+		imageData.push(image.data);
+	});
+	return Buffer.concat([header, ...imageData]);
+};
+//#endregion
+//#region src/app-icon.ts
+/**
+* ZIP entry used for the generated static application icon asset.
+*/
+var appIconAssetEntryName = "main/.muon/app-icon.png";
+/**
+* Runtime asset URL injected as the generated initial title bar icon.
+*/
+var appIconAssetUrl = "asset://main/.muon/app-icon.png";
+/**
+* Creates a static application icon source from API or CLI options.
+*/
+var createAppIconOptionsSource = (iconPath, directory, label = "iconPath") => {
+	if (iconPath === void 0) return;
+	if (typeof iconPath !== "string") throw new Error(`${label} must be a string when present.`);
+	if (iconPath.trim() === "") return;
+	return {
+		iconPath: iconPath.trim(),
+		directory
+	};
+};
+/**
+* Reads the top-level `iconPath` from a Muon config object.
+*/
+var readConfigAppIconSource = (config, directory, label) => {
+	const value = config.iconPath;
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new Error(`${label} iconPath must be a string when present.`);
+	return createAppIconOptionsSource(value, directory);
+};
+/**
+* Reads the top-level `iconPath` from project metadata.
+*/
+var readProjectAppIconSource = (projectJson, directory) => {
+	const value = projectJson.iconPath;
+	return typeof value === "string" ? createAppIconOptionsSource(value, directory) : void 0;
+};
+/**
+* Resolves and validates the first available static application icon source.
+*/
+var resolveMuonAppIconPath = async (sources) => {
+	for (const source of sources) {
+		const iconPath = resolveResourcePath$2(source.directory, source.iconPath);
+		await assertMuonAppIconPath(iconPath);
+		return iconPath;
+	}
+};
+var assertMuonAppIconPath = async (iconPath) => {
+	if ((0, node_path.extname)(iconPath).toLowerCase() !== ".png") throw new Error(`Muon app icon must be a .png file: ${iconPath}`);
+	if (!await fileExists$4(iconPath)) throw new Error(`Muon app icon does not exist: ${iconPath}`);
+	await createNormalizedIconPngData(await (0, node_fs_promises.readFile)(iconPath), iconPath, "Muon app icon");
+};
+var resolveResourcePath$2 = (directory, value) => (0, node_path.isAbsolute)(value) ? value : (0, node_path.resolve)(directory, value);
+var fileExists$4 = async (path) => {
+	try {
+		await (0, node_fs_promises.access)(path, node_fs.constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/windows-resource.ts
+var defaultConfigFileNames$1 = [
+	"muon.json5",
+	"muon.jsonc",
+	"muon.json"
+];
+var defaultLanguage = 1033;
+var defaultCodePage = 1200;
+var moduleDirectory$3 = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
+/**
+* Reads the Muon config file using the same default file names as muon build.
+*/
+var readMuonConfigForWindowsResource = async (root, configPath) => {
+	const resolvedConfigPath = await resolveConfigPath$1(root, configPath);
+	if (resolvedConfigPath === void 0) return {
+		config: {},
+		directory: root
+	};
+	return {
+		config: await readJsonObjectFile$2(resolvedConfigPath, "Muon config file"),
+		directory: (0, node_path.dirname)(resolvedConfigPath)
+	};
+};
+/**
+* Merges Windows resource options while preserving field-level fallback.
+*/
+var mergeMuonWindowsResourceOptions = (primary, fallback) => {
+	if (primary === void 0) return fallback;
+	if (fallback === void 0) return primary;
+	const merged = { ...fallback };
+	if (primary.iconPath !== void 0) merged.iconPath = primary.iconPath;
+	if (primary.productName !== void 0) merged.productName = primary.productName;
+	if (primary.fileDescription !== void 0) merged.fileDescription = primary.fileDescription;
+	if (primary.companyName !== void 0) merged.companyName = primary.companyName;
+	if (primary.version !== void 0) merged.version = primary.version;
+	if (primary.copyright !== void 0) merged.copyright = primary.copyright;
+	if (primary.language !== void 0) merged.language = primary.language;
+	if (primary.codePage !== void 0) merged.codePage = primary.codePage;
+	return merged;
+};
+/**
+* Resolves Windows resource metadata from options, config files, and package metadata.
+*/
+var resolveMuonWindowsResource = async (input) => {
+	const projectJson = await readProjectJson$1(input.root);
+	const windowsSources = [
+		createOptionsSource$1(input.options, input.root, "windowsResource"),
+		readConfigWindowsResourceSource(input.muonConfig, input.muonConfigDirectory, "muon.json"),
+		readConfigWindowsResourceSource(projectJson, input.root, "project.json")
+	].filter((source) => source !== void 0);
+	const sources = [
+		...windowsSources,
+		createProjectSource(projectJson, input.root),
+		createPackageSource(input.packageJson, input.root)
+	].filter((source) => source !== void 0);
+	const appIconSources = [
+		createAppIconOptionsSource(input.appIconPath, input.root),
+		readConfigAppIconSource(input.muonConfig, input.muonConfigDirectory, "muon.json"),
+		readProjectAppIconSource(projectJson, input.root)
+	].filter((source) => source !== void 0);
+	const productName = resolveStringField$1(sources, "productName", input.defaults.productName);
+	const fileDescription = resolveStringField$1(sources, "fileDescription", input.defaults.fileDescription);
+	const companyName = resolveStringField$1(sources, "companyName", input.defaults.companyName);
+	const version = resolveStringField$1(sources, "version", input.defaults.version);
+	const copyright = resolveOptionalStringField(sources, "copyright", input.defaults.copyright);
+	const language = resolveNumericField(sources, "language", defaultLanguage);
+	const codePage = resolveNumericField(sources, "codePage", defaultCodePage);
+	const fixedVersion = normalizeWindowsVersion(version);
+	return {
+		iconPath: await resolveWindowsIconPath(windowsSources, appIconSources, await resolveDefaultWindowsIcon(input.packageDirectory)),
+		productName,
+		fileDescription,
+		companyName,
+		version,
+		fixedVersion,
+		copyright,
+		language,
+		codePage
+	};
+};
+/**
+* Removes build-only Windows resource settings from runtime config.
+*/
+var stripBuildOnlyWindowsResourceConfig = (sourceConfig) => {
+	const sourceWindows = sourceConfig.windows;
+	if (!isJsonObject$3(sourceWindows)) return sourceConfig;
+	const windowsConfig = {};
+	for (const [key, value] of Object.entries(sourceWindows)) if (key !== "resource") windowsConfig[key] = value;
+	const output = {};
+	for (const [key, value] of Object.entries(sourceConfig)) if (key !== "windows") output[key] = value;
+	if (Object.keys(windowsConfig).length > 0) output.windows = windowsConfig;
+	return output;
+};
+/**
+* Returns true when the file has a Windows PE header.
+*/
+var isWindowsPeExecutable = async (path) => {
+	const content = await (0, node_fs_promises.readFile)(path);
+	if (content.length < 64 || content.toString("ascii", 0, 2) !== "MZ") return false;
+	const peOffset = content.readUInt32LE(60);
+	return peOffset + 4 <= content.length && content.toString("ascii", peOffset, peOffset + 4) === "PE\0\0";
+};
+/**
+* Applies resolved resource metadata to a Windows PE executable in place.
+*/
+var updateWindowsPeResources = async (input) => {
+	return await updateWindowsPeResourceFile(input, createEngraverUpdate);
+};
+/**
+* Applies only resolved icon metadata to a Windows PE executable in place.
+*/
+var updateWindowsPeIconResource = async (input) => {
+	return await updateWindowsPeResourceFile(input, createEngraverIconUpdate);
+};
+var updateWindowsPeResourceFile = async (input, createUpdate) => {
+	if (!await isWindowsPeExecutable(input.executablePath)) return false;
+	const mode = (await (0, node_fs_promises.stat)(input.executablePath)).mode & 511;
+	const tempDirectory = await (0, node_fs_promises.mkdtemp)((0, node_path.join)((0, node_os.tmpdir)(), "muon-windows-resource-"));
+	const updatesJsonPath = (0, node_path.join)(tempDirectory, "updates.json");
+	const outputPath = (0, node_path.join)(tempDirectory, "output.exe");
+	const iconPath = (0, node_path.join)(tempDirectory, "icon.ico");
+	try {
+		await createWindowsIconFromPngFile(input.resource.iconPath, iconPath);
+		await (0, node_fs_promises.writeFile)(updatesJsonPath, `${JSON.stringify(createUpdate(input.resource, iconPath), null, 2)}\n`);
+		await runMuonPrepareResourceUpdate({
+			inputPath: input.executablePath,
+			updatesJsonPath,
+			outputPath,
+			quiet: true,
+			prepareExecutablePath: void 0,
+			environment: input.environment,
+			cwd: input.cwd
+		});
+		await (0, node_fs_promises.copyFile)(outputPath, input.executablePath);
+		await (0, node_fs_promises.chmod)(input.executablePath, mode === 0 ? 493 : mode);
+		return true;
+	} finally {
+		await (0, node_fs_promises.rm)(tempDirectory, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+var createEngraverUpdate = (resource, iconPath) => {
+	const strings = {
+		CompanyName: resource.companyName,
+		FileDescription: resource.fileDescription,
+		FileVersion: resource.version,
+		ProductName: resource.productName,
+		ProductVersion: resource.version
+	};
+	if (resource.copyright !== void 0) strings.LegalCopyright = resource.copyright;
+	return {
+		version: {
+			language: resource.language,
+			codePage: resource.codePage,
+			fixed: {
+				fileVersion: resource.fixedVersion,
+				productVersion: resource.fixedVersion,
+				fileOS: "windows32",
+				fileType: "app"
+			},
+			strings
+		},
+		icons: createEngraverIcons(resource, iconPath)
+	};
+};
+var createEngraverIconUpdate = (resource, iconPath) => ({ icons: createEngraverIcons(resource, iconPath) });
+var createEngraverIcons = (resource, iconPath) => [{
+	id: 1,
+	language: resource.language,
+	path: iconPath
+}];
+var resolveConfigPath$1 = async (root, configPath) => {
+	if (configPath !== void 0) {
+		const resolvedPath = (0, node_path.resolve)(root, configPath);
+		if (await fileExists$3(resolvedPath)) return resolvedPath;
+		throw new Error(`Muon config file does not exist: ${resolvedPath}`);
+	}
+	for (const fileName of defaultConfigFileNames$1) {
+		const candidatePath = (0, node_path.join)(root, fileName);
+		if (await fileExists$3(candidatePath)) return candidatePath;
+	}
+};
+var readProjectJson$1 = async (root) => {
+	const projectJsonPath = (0, node_path.join)(root, "project.json");
+	if (!await fileExists$3(projectJsonPath)) return {};
+	return await readJsonObjectFile$2(projectJsonPath, "project.json");
+};
+var readJsonObjectFile$2 = async (filePath, label) => {
+	const parsed = (0, import_dist.parse)(await (0, node_fs_promises.readFile)(filePath, "utf8"));
+	if (!isJsonObject$3(parsed)) throw new Error(`${label} must contain a JSON object: ${filePath}`);
+	return parsed;
+};
+var createOptionsSource$1 = (options, directory, label) => {
+	if (options === void 0) return;
+	return {
+		options: validateWindowsResourceOptions(options, label),
+		directory
+	};
+};
+var readConfigWindowsResourceSource = (config, directory, label) => {
+	const windows = config.windows;
+	if (windows === void 0) return;
+	if (!isJsonObject$3(windows)) throw new Error(`${label} windows must be an object when present.`);
+	const resource = windows.resource;
+	if (resource === void 0) return;
+	return createOptionsSource$1(validateWindowsResourceOptions(resource, `${label} windows.resource`), directory, `${label} windows.resource`);
+};
+var createProjectSource = (projectJson, directory) => {
+	const topLevel = {};
+	copyStringField(projectJson, "productName", topLevel, "productName");
+	copyStringField(projectJson, "name", topLevel, "productName");
+	copyStringField(projectJson, "fileDescription", topLevel, "fileDescription");
+	copyStringField(projectJson, "description", topLevel, "fileDescription");
+	copyStringField(projectJson, "companyName", topLevel, "companyName");
+	copyStringField(projectJson, "version", topLevel, "version");
+	copyStringField(projectJson, "copyright", topLevel, "copyright");
+	const author = stringifyAuthor(projectJson.author);
+	if (author !== void 0 && topLevel.companyName === void 0) topLevel.companyName = author;
+	const options = mergeMuonWindowsResourceOptions(readConfigWindowsResourceSource(projectJson, directory, "project.json")?.options, topLevel);
+	if (options === void 0 || Object.keys(options).length === 0) return;
+	return {
+		options,
+		directory
+	};
+};
+var createPackageSource = (packageJson, directory) => {
+	const options = {};
+	copyStringField(packageJson, "name", options, "productName");
+	copyStringField(packageJson, "description", options, "fileDescription");
+	copyStringField(packageJson, "version", options, "version");
+	copyStringField(packageJson, "copyright", options, "copyright");
+	const author = stringifyAuthor(packageJson.author);
+	if (author !== void 0) options.companyName = author;
+	return Object.keys(options).length === 0 ? void 0 : {
+		options,
+		directory
+	};
+};
+var copyStringField = (source, sourceKey, target, targetKey) => {
+	const value = source[sourceKey];
+	if (typeof value === "string" && value.trim() !== "") target[targetKey] = value.trim();
+};
+var validateWindowsResourceOptions = (value, label) => {
+	if (!isJsonObject$3(value)) throw new Error(`${label} must be an object.`);
+	const output = {};
+	copyOptionalStringResourceField(value, "iconPath", output);
+	copyOptionalStringResourceField(value, "productName", output);
+	copyOptionalStringResourceField(value, "fileDescription", output);
+	copyOptionalStringResourceField(value, "companyName", output);
+	copyOptionalStringResourceField(value, "version", output);
+	copyOptionalStringResourceField(value, "copyright", output);
+	copyOptionalNumberResourceField(value, "language", output, label);
+	copyOptionalNumberResourceField(value, "codePage", output, label);
+	return output;
+};
+var copyOptionalStringResourceField = (source, key, target) => {
+	const value = source[key];
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new Error(`${key} must be a string when present.`);
+	if (value.trim() !== "") target[key] = value.trim();
+};
+var copyOptionalNumberResourceField = (source, key, target, label) => {
+	const value = source[key];
+	if (value === void 0) return;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 65535) throw new Error(`${label} ${key} must be an integer from 0 to 65535.`);
+	target[key] = value;
+};
+var resolveStringField$1 = (sources, field, fallback) => {
+	return resolveOptionalStringField(sources, field, fallback) ?? fallback;
+};
+var resolveOptionalStringField = (sources, field, fallback) => {
+	for (const source of sources) {
+		const value = source.options[field];
+		if (value !== void 0 && value.trim() !== "") return value.trim();
+	}
+	return fallback;
+};
+var resolveNumericField = (sources, field, fallback) => {
+	for (const source of sources) {
+		const value = source.options[field];
+		if (value !== void 0) return value;
+	}
+	return fallback;
+};
+var resolveWindowsIconPath = async (windowsSources, appIconSources, defaultIconPath) => {
+	for (const source of windowsSources) {
+		const value = source.options.iconPath;
+		if (value !== void 0 && value.trim() !== "") {
+			const iconPath = resolveResourcePath$1(source.directory, value);
+			await assertIconPath$1(iconPath);
+			return iconPath;
+		}
+	}
+	const appIconPath = await resolveMuonAppIconPath(appIconSources);
+	if (appIconPath !== void 0) return appIconPath;
+	await assertIconPath$1(defaultIconPath);
+	return defaultIconPath;
+};
+var assertIconPath$1 = async (iconPath) => {
+	if ((0, node_path.extname)(iconPath).toLowerCase() !== ".png") throw new Error(`Windows resource icon must be a .png file: ${iconPath}`);
+	if (!await fileExists$3(iconPath)) throw new Error(`Windows resource icon does not exist: ${iconPath}`);
+	await createNormalizedMuonIconPngData(await (0, node_fs_promises.readFile)(iconPath), iconPath);
+};
+var resolveDefaultWindowsIcon = async (packageDirectory) => {
+	const sourceIconPath = (0, node_path.join)(moduleDirectory$3, "..", "..", "images", "muon-256.png");
+	const candidates = [
+		(0, node_path.join)((0, node_path.resolve)(packageDirectory), "native", "muon-256.png"),
+		(0, node_path.join)(moduleDirectory$3, "native", "muon-256.png"),
+		(0, node_path.join)(moduleDirectory$3, "..", "dist", "native", "muon-256.png"),
+		sourceIconPath
+	];
+	for (const candidate of candidates) if (await fileExists$3(candidate)) return candidate;
+	return sourceIconPath;
+};
+var resolveResourcePath$1 = (directory, path) => {
+	return (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(directory, path);
+};
+var normalizeWindowsVersion = (version) => {
+	const normalized = version.trim();
+	const match = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?(?:$|[-+])/.exec(normalized);
+	if (match === null) throw new Error(`Windows resource version must start with numeric parts: ${version}`);
+	const values = [
+		match[1],
+		match[2],
+		match[3],
+		match[4]
+	].map((value) => value === void 0 ? 0 : Number.parseInt(value, 10));
+	for (const value of values) if (!Number.isInteger(value) || value < 0 || value > 65535) throw new Error(`Windows resource version part must be from 0 to 65535: ${version}`);
+	return values.join(".");
+};
+var stringifyAuthor = (value) => {
+	if (typeof value === "string" && value.trim() !== "") return value.trim();
+	if (!isJsonObject$3(value) || typeof value.name !== "string") return;
+	const name = value.name.trim();
+	if (name === "") return;
+	return value.email === void 0 || typeof value.email !== "string" ? name : `${name} <${value.email}>`;
+};
+var fileExists$3 = async (path) => {
+	try {
+		await (0, node_fs_promises.access)(path, node_fs.constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var isJsonObject$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+//#region src/linux-desktop.ts
+var defaultIconFileName = "muon-desktop-icon.png";
+var defaultDesktopConfigFileName = "muon-desktop.json";
+var moduleDirectory$2 = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
+/**
+* Merges Linux desktop options while preserving field-level fallback.
+*/
+var mergeMuonLinuxDesktopOptions = (primary, fallback) => {
+	if (primary === void 0) return fallback;
+	if (fallback === void 0) return primary;
+	const merged = { ...fallback };
+	if (primary.desktopId !== void 0) merged.desktopId = primary.desktopId;
+	if (primary.name !== void 0) merged.name = primary.name;
+	if (primary.comment !== void 0) merged.comment = primary.comment;
+	if (primary.iconPath !== void 0) merged.iconPath = primary.iconPath;
+	if (primary.categories !== void 0) merged.categories = primary.categories;
+	if (primary.startupNotify !== void 0) merged.startupNotify = primary.startupNotify;
+	return merged;
+};
+/**
+* Resolves Linux desktop integration metadata from options, config files, and
+* package metadata.
+*/
+var resolveMuonLinuxDesktop = async (input) => {
+	const projectJson = await readProjectJson(input.root);
+	const sources = [createOptionsSource(input.options, input.root, "linuxDesktop"), readConfigLinuxDesktopSource(input.muonConfig, input.muonConfigDirectory, "muon.json")].filter((source) => source !== void 0);
+	const appIconSources = [
+		createAppIconOptionsSource(input.appIconPath, input.root),
+		readConfigAppIconSource(input.muonConfig, input.muonConfigDirectory, "muon.json"),
+		readProjectAppIconSource(projectJson, input.root)
+	].filter((source) => source !== void 0);
+	return {
+		desktopId: sanitizeDesktopId(resolveStringField(sources, "desktopId", input.defaults.desktopId)),
+		name: resolveStringField(sources, "name", input.defaults.name),
+		comment: resolveStringField(sources, "comment", input.defaults.comment),
+		categories: resolveCategories(sources, input.defaults.categories),
+		startupNotify: resolveBooleanField(sources, "startupNotify", input.defaults.startupNotify),
+		iconPath: await resolveLinuxIconPath(sources, appIconSources, await resolveDefaultLinuxDesktopIcon(input.packageDirectory)),
+		iconFileName: defaultIconFileName,
+		configFileName: defaultDesktopConfigFileName
+	};
+};
+/**
+* Removes build-only Linux desktop settings from runtime config.
+*/
+var stripBuildOnlyLinuxDesktopConfig = (sourceConfig) => {
+	const sourceLinux = sourceConfig.linux;
+	if (!isJsonObject$2(sourceLinux)) return sourceConfig;
+	const linuxConfig = {};
+	for (const [key, value] of Object.entries(sourceLinux)) if (key !== "desktop") linuxConfig[key] = value;
+	const output = {};
+	for (const [key, value] of Object.entries(sourceConfig)) if (key !== "linux") output[key] = value;
+	if (Object.keys(linuxConfig).length > 0) output.linux = linuxConfig;
+	return output;
+};
+/**
+* Writes normalized Linux desktop sidecar files into a target distribution.
+*/
+var writeLinuxDesktopDistributionFiles = async (outputPath, desktop) => {
+	const iconData = await createNormalizedIconPngData(await (0, node_fs_promises.readFile)(desktop.iconPath), desktop.iconPath, "Linux desktop icon");
+	await (0, node_fs_promises.writeFile)((0, node_path.join)(outputPath, desktop.iconFileName), iconData);
+	await (0, node_fs_promises.writeFile)((0, node_path.join)(outputPath, desktop.configFileName), `${JSON.stringify({
+		desktopId: desktop.desktopId,
+		name: desktop.name,
+		comment: desktop.comment,
+		categories: desktop.categories,
+		startupNotify: desktop.startupNotify,
+		iconFileName: desktop.iconFileName
+	}, void 0, 2)}\n`);
+};
+/**
+* Creates a Desktop Entry file.
+*/
+var createLinuxDesktopEntry = (input) => {
+	const lines = [
+		"[Desktop Entry]",
+		"Type=Application",
+		`Name=${escapeDesktopString(input.desktop.name)}`
+	];
+	if (input.desktop.comment.length > 0) lines.push(`Comment=${escapeDesktopString(input.desktop.comment)}`);
+	lines.push(`Exec=${input.exec}`);
+	lines.push(`TryExec=${input.tryExec}`);
+	lines.push(`Icon=${escapeDesktopString(input.icon)}`);
+	lines.push(`Terminal=false`);
+	if (input.desktop.categories.length > 0) lines.push(`Categories=${input.desktop.categories.join(";")};`);
+	lines.push(`StartupNotify=${input.desktop.startupNotify ? "true" : "false"}`);
+	lines.push(`StartupWMClass=${escapeDesktopString(input.desktop.desktopId)}`);
+	lines.push("X-Muon-Managed=true");
+	lines.push("");
+	return lines.join("\n");
+};
+/**
+* Quotes one Desktop Entry Exec argument.
+*/
+var quoteDesktopExecArgument = (value) => {
+	let escaped = "\"";
+	for (const character of value) {
+		if (character === "\"" || character === "\\" || character === "$" || character === "`") escaped += "\\";
+		escaped += character;
+	}
+	return `${escaped}"`;
+};
+var readJsonObjectFile$1 = async (filePath, label) => {
+	const parsed = (0, import_dist.parse)(await (0, node_fs_promises.readFile)(filePath, "utf8"));
+	if (!isJsonObject$2(parsed)) throw new Error(`${label} must contain a JSON object: ${filePath}`);
+	return parsed;
+};
+var readProjectJson = async (root) => {
+	const projectJsonPath = (0, node_path.join)(root, "project.json");
+	if (!await fileExists$2(projectJsonPath)) return {};
+	return await readJsonObjectFile$1(projectJsonPath, "project.json");
+};
+var createOptionsSource = (options, directory, label) => {
+	if (options === void 0) return;
+	return {
+		options: validateLinuxDesktopOptions(options, label),
+		directory
+	};
+};
+var readConfigLinuxDesktopSource = (config, directory, label) => {
+	const linux = config.linux;
+	if (linux === void 0) return;
+	if (!isJsonObject$2(linux)) throw new Error(`${label} linux must be an object when present.`);
+	const desktop = linux.desktop;
+	if (desktop === void 0) return;
+	return createOptionsSource(validateLinuxDesktopOptions(desktop, `${label} linux.desktop`), directory, `${label} linux.desktop`);
+};
+var validateLinuxDesktopOptions = (value, label) => {
+	if (!isJsonObject$2(value)) throw new Error(`${label} must be an object.`);
+	const output = {};
+	copyOptionalStringDesktopField(value, "desktopId", output);
+	copyOptionalStringDesktopField(value, "name", output);
+	copyOptionalStringDesktopField(value, "comment", output);
+	copyOptionalStringDesktopField(value, "iconPath", output);
+	copyOptionalCategoriesField(value, output, label);
+	copyOptionalBooleanDesktopField(value, "startupNotify", output, label);
+	return output;
+};
+var copyOptionalStringDesktopField = (source, key, target) => {
+	const value = source[key];
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new Error(`${key} must be a string when present.`);
+	if (value.trim() !== "") target[key] = value.trim();
+};
+var copyOptionalCategoriesField = (source, target, label) => {
+	const value = source.categories;
+	if (value === void 0) return;
+	if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string" && entry.trim() !== "" && !entry.includes(";") && !entry.includes("\n") && !entry.includes("\r"))) throw new Error(`${label} categories must be a string array without semicolons when present.`);
+	target.categories = value.map((entry) => entry.trim());
+};
+var copyOptionalBooleanDesktopField = (source, key, target, label) => {
+	const value = source[key];
+	if (value === void 0) return;
+	if (typeof value !== "boolean") throw new Error(`${label} ${key} must be a boolean when present.`);
+	target[key] = value;
+};
+var resolveStringField = (sources, field, fallback) => {
+	for (const source of sources) {
+		const value = source.options[field];
+		if (value !== void 0 && value.trim() !== "") return value.trim();
+	}
+	return fallback;
+};
+var resolveCategories = (sources, fallback) => {
+	for (const source of sources) if (source.options.categories !== void 0) return source.options.categories;
+	return fallback;
+};
+var resolveBooleanField = (sources, field, fallback) => {
+	for (const source of sources) {
+		const value = source.options[field];
+		if (value !== void 0) return value;
+	}
+	return fallback;
+};
+var resolveLinuxIconPath = async (sources, appIconSources, defaultIconPath) => {
+	for (const source of sources) {
+		const value = source.options.iconPath;
+		if (value !== void 0 && value.trim() !== "") {
+			const iconPath = resolveResourcePath(source.directory, value);
+			await assertIconPath(iconPath, true);
+			return iconPath;
+		}
+	}
+	const appIconPath = await resolveMuonAppIconPath(appIconSources);
+	if (appIconPath !== void 0) return appIconPath;
+	if (defaultIconPath !== void 0 && await fileExists$2(defaultIconPath)) {
+		await assertIconPath(defaultIconPath, false);
+		return defaultIconPath;
+	}
+	throw new Error("Linux desktop icon does not exist.");
+};
+var assertIconPath = async (iconPath, required) => {
+	if ((0, node_path.extname)(iconPath).toLowerCase() !== ".png") throw new Error(`Linux desktop icon must be a .png file: ${iconPath}`);
+	if (required && !await fileExists$2(iconPath)) throw new Error(`Linux desktop icon does not exist: ${iconPath}`);
+	if (await fileExists$2(iconPath)) await createNormalizedIconPngData(await (0, node_fs_promises.readFile)(iconPath), iconPath, "Linux desktop icon");
+};
+var resolveDefaultLinuxDesktopIcon = async (packageDirectory) => {
+	const candidates = [
+		(0, node_path.join)((0, node_path.resolve)(packageDirectory), "native", "muon-256.png"),
+		(0, node_path.join)(moduleDirectory$2, "native", "muon-256.png"),
+		(0, node_path.join)(moduleDirectory$2, "..", "dist", "native", "muon-256.png"),
+		(0, node_path.join)(moduleDirectory$2, "..", "..", "images", "muon-256.png")
+	];
+	for (const candidate of candidates) if (await fileExists$2(candidate)) return candidate;
+};
+var sanitizeDesktopId = (value) => {
+	const sanitized = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[.-]+/g, "").replace(/[.-]+$/g, "");
+	return sanitized.length > 0 ? sanitized : "muon-app";
+};
+var escapeDesktopString = (value) => value.replaceAll("\\", "\\\\").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t");
+var resolveResourcePath = (directory, path) => {
+	return (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(directory, path);
+};
+var fileExists$2 = async (path) => {
+	try {
+		await (0, node_fs_promises.access)(path, node_fs.constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var isJsonObject$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
 //#region src/build.ts
 var AdmZip = __resolveDefaultExport(adm_zip.default, false);
 globalThis.__screwUpIsInCJS_f9d0012cc677 = true;
@@ -1922,18 +2905,58 @@ var buildMuonApp = async (options = {}) => {
 	const appName = resolveAppName(packageJson, options.appName);
 	const appId = resolveAppId(packageJson, options.appId);
 	const buildConfig = await readBuildConfig(root, options.configPath);
-	const assetInput = resolveAssetInput(root, options.assetSourcePath, options.assetPrefix, buildConfig);
+	const sourceConfig = applyRuntimePluginConfig(buildConfig.config, options.runtimePluginConfig ?? { mode: "simple" });
+	assertNoUserInitialTitleBarIcon(sourceConfig);
+	const resolvedBuildConfig = {
+		...buildConfig,
+		config: sourceConfig
+	};
+	const assetInput = resolveAssetInput(root, options.assetSourcePath, options.assetPrefix, resolvedBuildConfig);
+	const windowsResource = await resolveMuonWindowsResource({
+		root,
+		packageDirectory,
+		packageJson,
+		muonConfig: sourceConfig,
+		muonConfigDirectory: buildConfig.directory,
+		options: options.windowsResource,
+		appIconPath: options.iconPath,
+		defaults: {
+			productName: appName,
+			fileDescription: appName,
+			companyName: "Unknown",
+			version: "0.0.0",
+			copyright: void 0
+		}
+	});
+	const linuxDesktop = await resolveMuonLinuxDesktop({
+		root,
+		packageDirectory,
+		muonConfig: sourceConfig,
+		muonConfigDirectory: buildConfig.directory,
+		options: options.linuxDesktop,
+		appIconPath: options.iconPath,
+		defaults: {
+			desktopId: appId,
+			name: resolveLinuxDesktopDefaultName(packageJson, appName),
+			comment: resolvePackageDescription(packageJson),
+			categories: ["Utility"],
+			startupNotify: true
+		}
+	});
 	const salt = Buffer.from(options.assetSalt ?? (0, node_crypto.randomBytes)(assetSaltByteLength));
 	const results = [];
 	for (const target of targets) {
 		const result = await buildMuonTarget({
 			packageDirectory,
+			root,
 			outputRoot,
 			appName,
 			appId,
 			target,
 			assetInput,
-			sourceConfig: buildConfig.config,
+			sourceConfig,
+			windowsResource,
+			linuxDesktop,
 			salt
 		});
 		results.push(result);
@@ -1991,6 +3014,8 @@ var sanitizeAppId = (value) => {
 	const sanitized = (value.startsWith("@") ? value.slice(1) : value).trim().toLowerCase().replace("/", ".").replace(/[^a-z0-9._-]+/g, ".").replace(/^[.]+/g, "").replace(/[.]+$/g, "");
 	return sanitized.length > 0 ? sanitized : defaultAppId;
 };
+var resolveLinuxDesktopDefaultName = (packageJson, appName) => typeof packageJson.name === "string" && packageJson.name.trim() !== "" ? packageJson.name.trim() : appName;
+var resolvePackageDescription = (packageJson) => typeof packageJson.description === "string" ? packageJson.description.trim() : "";
 var readBuildConfig = async (root, configPath) => {
 	const resolvedConfigPath = await resolveConfigPath(root, configPath);
 	if (resolvedConfigPath === void 0) return {
@@ -2002,6 +3027,19 @@ var readBuildConfig = async (root, configPath) => {
 		directory: (0, node_path.dirname)(resolvedConfigPath)
 	};
 };
+var applyRuntimePluginConfig = (sourceConfig, runtimePluginConfig) => {
+	if (runtimePluginConfig === void 0) return sourceConfig;
+	const sourcePlugin = sourceConfig.plugin;
+	if (sourcePlugin !== void 0 && !isJsonObject$1(sourcePlugin)) throw new Error("muon.json plugin must be an object when runtime plugin config is applied.");
+	const plugin = sourcePlugin ?? {};
+	return {
+		...sourceConfig,
+		plugin: {
+			...plugin,
+			...runtimePluginConfig
+		}
+	};
+};
 var readConfigAssetSourcePath = (sourceConfig) => {
 	const sourceAsset = sourceConfig.asset;
 	if (sourceAsset === void 0) return;
@@ -2045,6 +3083,8 @@ var buildMuonTarget = async (input) => {
 	const outputPath = (0, node_path.join)(input.outputRoot, descriptor.distributionDirectoryName);
 	const launcherPath = (0, node_path.join)(outputPath, getLauncherFileName(input.appName, descriptor));
 	const assetZipPath = (0, node_path.join)(outputPath, "assets.zip");
+	const runtimeAppId = getMuonTargetRuntimeAppId(input.appId, input.target);
+	const appIconPath = descriptor.os === "windows" ? input.windowsResource.iconPath : input.linuxDesktop.iconPath;
 	await verifyTargetInputs({
 		sourceRuntimePath,
 		sourceBootstrapPath,
@@ -2063,8 +3103,11 @@ var buildMuonTarget = async (input) => {
 	await (0, node_fs_promises.chmod)((0, node_path.join)(outputPath, descriptor.runtimeExecutableName), executableMode);
 	await (0, node_fs_promises.copyFile)(sourceBootstrapPath, launcherPath);
 	await (0, node_fs_promises.chmod)(launcherPath, executableMode);
-	const asset = await writeAssetArchive(input.assetInput, assetZipPath, input.salt);
-	const embeddedConfig = createEmbeddedConfig(input.sourceConfig, asset, input.appId);
+	const asset = await writeAssetArchive(input.assetInput, assetZipPath, input.salt, [{
+		name: appIconAssetEntryName,
+		data: await (0, node_fs_promises.readFile)(appIconPath)
+	}]);
+	const embeddedConfig = createEmbeddedConfig(input.sourceConfig, asset, runtimeAppId, input.linuxDesktop.desktopId, appIconAssetUrl);
 	await withTemporaryConfig(embeddedConfig, async (configPath) => {
 		await embedMuonConfigInRuntime({
 			runtimePath: outputPath,
@@ -2077,13 +3120,29 @@ var buildMuonTarget = async (input) => {
 			outputPath: void 0
 		});
 	});
+	if (descriptor.os === "windows") {
+		await updateWindowsPeIconResource({
+			executablePath: (0, node_path.join)(outputPath, descriptor.runtimeExecutableName),
+			resource: input.windowsResource,
+			environment: process.env,
+			cwd: input.root
+		});
+		await updateWindowsPeResources({
+			executablePath: launcherPath,
+			resource: input.windowsResource,
+			environment: process.env,
+			cwd: input.root
+		});
+	} else if (descriptor.os === "linux") await writeLinuxDesktopDistributionFiles(outputPath, input.linuxDesktop);
 	return {
 		target: input.target,
 		distributionDirectoryName: descriptor.distributionDirectoryName,
 		outputPath,
 		launcherPath,
 		asset,
-		embeddedConfig
+		runtimeAppId,
+		embeddedConfig,
+		...descriptor.os === "linux" ? { linuxDesktop: input.linuxDesktop } : {}
 	};
 };
 var verifyTargetInputs = async (input) => {
@@ -2104,10 +3163,10 @@ var copyRuntimeFiles = async (sourceRuntimePath, outputPath, descriptor) => {
 	}
 	await (0, node_fs_promises.copyFile)((0, node_path.join)(sourceRuntimePath, muonLicenseFileName), (0, node_path.join)(outputPath, muonLicenseFileName));
 };
-var writeAssetArchive = async (input, outputPath, salt) => {
+var writeAssetArchive = async (input, outputPath, salt, extraEntries) => {
 	const sourceStats = await statOrUndefined(input.sourcePath);
 	if (sourceStats === void 0) throw new Error(`Muon asset source does not exist: ${input.sourcePath}`);
-	const archive = sourceStats.isDirectory() ? await createAssetArchiveFromDirectory(input) : sourceStats.isFile() ? await (0, node_fs_promises.readFile)(input.sourcePath) : void 0;
+	const archive = sourceStats.isDirectory() ? await createAssetArchiveFromDirectory(input, extraEntries) : sourceStats.isFile() ? await createAssetArchiveFromZipFile(input.sourcePath, extraEntries) : void 0;
 	if (archive === void 0) throw new Error(`Muon asset source is not a directory or file: ${input.sourcePath}`);
 	await (0, node_fs_promises.writeFile)(outputPath, archive);
 	return {
@@ -2117,10 +3176,30 @@ var writeAssetArchive = async (input, outputPath, salt) => {
 		entryCount: sourceStats.isDirectory() ? readZipEntryCount(archive, outputPath) : readZipEntryCount(archive, input.sourcePath)
 	};
 };
-var createAssetArchiveFromDirectory = async (input) => {
+var createAssetArchiveFromDirectory = async (input, extraEntries) => {
 	const entries = await collectZipEntries(input.sourcePath, input.prefix);
 	if (entries.length === 0) throw new Error(`Muon asset source has no files: ${input.sourcePath}`);
-	return createZipArchive(entries);
+	return createZipArchive(appendZipEntries(entries, extraEntries));
+};
+var createAssetArchiveFromZipFile = async (sourcePath, extraEntries) => {
+	const zip = new AdmZip(await (0, node_fs_promises.readFile)(sourcePath));
+	for (const entry of extraEntries) {
+		assertSafeZipEntryName(entry.name);
+		if (zip.getEntry(entry.name) !== null) throw new Error(`Muon app icon asset entry already exists: ${entry.name}`);
+		zip.addFile(entry.name, entry.data);
+	}
+	return zip.toBuffer();
+};
+var appendZipEntries = (entries, extraEntries) => {
+	const output = [...entries];
+	const names = new Set(entries.map((entry) => entry.name));
+	for (const entry of extraEntries) {
+		assertSafeZipEntryName(entry.name);
+		if (names.has(entry.name)) throw new Error(`Muon app icon asset entry already exists: ${entry.name}`);
+		names.add(entry.name);
+		output.push(entry);
+	}
+	return output;
 };
 var readZipEntryCount = (archive, sourcePath) => {
 	const endSignature = 101010256;
@@ -2158,13 +3237,20 @@ var createZipArchive = (entries) => {
 	for (const entry of entries) zip.addFile(entry.name, entry.data);
 	return zip.toBuffer();
 };
-var createEmbeddedConfig = (sourceConfig, asset, appId) => {
+var createEmbeddedConfig = (sourceConfig, asset, appId, desktopId, initialTitleBarIcon) => {
 	const sourceAsset = sourceConfig.asset;
 	if (sourceAsset !== void 0 && !isJsonObject$1(sourceAsset)) throw new Error("muon.json asset must be an object when present.");
 	const sourceBootstrap = sourceConfig.bootstrap;
 	if (sourceBootstrap !== void 0 && !isJsonObject$1(sourceBootstrap)) throw new Error("muon.json bootstrap must be an object when present.");
+	const runtimeConfig = stripBuildOnlyAppIconConfig(stripBuildOnlyLinuxDesktopConfig(stripBuildOnlyWindowsResourceConfig(sourceConfig)));
+	const sourceBrowser = runtimeConfig.browser;
+	if (sourceBrowser !== void 0 && !isJsonObject$1(sourceBrowser)) throw new Error("muon.json browser must be an object when present.");
 	return {
-		...sourceConfig,
+		...runtimeConfig,
+		browser: {
+			...sourceBrowser ?? {},
+			initialTitleBarIcon
+		},
 		asset: {
 			...sourceAsset ?? {},
 			sourcePath: appConfigSourcePath,
@@ -2173,10 +3259,22 @@ var createEmbeddedConfig = (sourceConfig, asset, appId) => {
 		},
 		bootstrap: {
 			...sourceBootstrap ?? {},
-			appId
+			appId,
+			desktopId
 		}
 	};
 };
+var assertNoUserInitialTitleBarIcon = (sourceConfig) => {
+	const sourceBrowser = sourceConfig.browser;
+	if (sourceBrowser === void 0) return;
+	if (!isJsonObject$1(sourceBrowser)) throw new Error("muon.json browser must be an object when present.");
+	if (sourceBrowser.initialTitleBarIcon !== void 0) throw new Error("muon.json browser.initialTitleBarIcon is generated by muon build; use top-level iconPath instead.");
+};
+var stripBuildOnlyAppIconConfig = (sourceConfig) => {
+	const output = {};
+	for (const [key, value] of Object.entries(sourceConfig)) if (key !== "iconPath") output[key] = value;
+	return output;
+};
 var withTemporaryConfig = async (config, callback) => {
 	const tempDirectory = await (0, node_fs_promises.mkdtemp)((0, node_path.join)((0, node_os.tmpdir)(), "muon-build-config-"));
 	const configPath = (0, node_path.join)(tempDirectory, "muon.json");
@@ -2218,6 +3316,203 @@ var isJsonObject$1 = (value) => {
 };
 var getErrorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
 //#endregion
+//#region src/vite-options.ts
+/**
+* Metadata symbol used to recover `muon()` plugin options from `vite.config.*`.
+*/
+var muonVitePluginOptionsSymbol = Symbol.for("muon.vite.plugin.options");
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+var isWindowsResourceOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return (value.iconPath === void 0 || typeof value.iconPath === "string") && (value.productName === void 0 || typeof value.productName === "string") && (value.fileDescription === void 0 || typeof value.fileDescription === "string") && (value.companyName === void 0 || typeof value.companyName === "string") && (value.version === void 0 || typeof value.version === "string") && (value.copyright === void 0 || typeof value.copyright === "string") && (value.language === void 0 || typeof value.language === "number" && Number.isInteger(value.language)) && (value.codePage === void 0 || typeof value.codePage === "number" && Number.isInteger(value.codePage));
+};
+var isLinuxDesktopOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return (value.desktopId === void 0 || typeof value.desktopId === "string") && (value.name === void 0 || typeof value.name === "string") && (value.comment === void 0 || typeof value.comment === "string") && (value.iconPath === void 0 || typeof value.iconPath === "string") && (value.categories === void 0 || isStringArray(value.categories)) && (value.startupNotify === void 0 || typeof value.startupNotify === "boolean");
+};
+var isMuonViteBuildOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return (value.targets === void 0 || isStringArray(value.targets)) && (value.allTargets === void 0 || typeof value.allTargets === "boolean") && (value.appName === void 0 || typeof value.appName === "string") && (value.appId === void 0 || typeof value.appId === "string") && (value.outputRoot === void 0 || typeof value.outputRoot === "string") && (value.configPath === void 0 || typeof value.configPath === "string") && (value.iconPath === void 0 || typeof value.iconPath === "string") && (value.windowsResource === void 0 || isWindowsResourceOptions(value.windowsResource)) && (value.linuxDesktop === void 0 || isLinuxDesktopOptions(value.linuxDesktop)) && (value.packageDirectory === void 0 || typeof value.packageDirectory === "string") && (value.assetSalt === void 0 || value.assetSalt instanceof Uint8Array);
+};
+var isMuonVitePluginAccessImportOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return (value.sources === void 0 || isStringArray(value.sources)) && (value.packages === void 0 || isStringArray(value.packages)) && (value.allow === void 0 || isStringArray(value.allow));
+};
+var isMuonVitePluginAccessEntryOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return typeof value.name === "string" && (value.signature === void 0 || typeof value.signature === "string") && (value.salt === void 0 || typeof value.salt === "string") && (value.allow === void 0 || isStringArray(value.allow)) && (value.imports === void 0 || Array.isArray(value.imports) && value.imports.every(isMuonVitePluginAccessImportOptions));
+};
+var isMuonVitePluginAccessOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return (value.path === void 0 || typeof value.path === "string") && (value.mode === void 0 || value.mode === "simple" || value.mode === "validate") && (value.pages === void 0 || isStringArray(value.pages)) && (value.plugins === void 0 || Array.isArray(value.plugins) && value.plugins.every(isMuonVitePluginAccessEntryOptions));
+};
+var isMuonVitePluginOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return (value.muonPath === void 0 || typeof value.muonPath === "string") && (value.cefPath === void 0 || typeof value.cefPath === "string") && (value.stagePath === void 0 || typeof value.stagePath === "string") && (value.open === void 0 || typeof value.open === "boolean") && (value.enableDebugger === void 0 || typeof value.enableDebugger === "boolean") && (value.pluginAccess === void 0 || value.pluginAccess === false || isMuonVitePluginAccessOptions(value.pluginAccess)) && (value.build === void 0 || typeof value.build === "boolean" || isMuonViteBuildOptions(value.build));
+};
+/**
+* Attaches raw Muon Vite plugin options to a plugin instance.
+*
+* @param plugin Plugin object.
+* @param options Raw plugin options.
+* @returns Plugin object with internal Muon metadata.
+*/
+var attachMuonVitePluginOptions = (plugin, options) => {
+	Object.defineProperty(plugin, muonVitePluginOptionsSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: { ...options },
+		writable: false
+	});
+	return plugin;
+};
+/**
+* Reads raw Muon Vite plugin options from a plugin instance.
+*
+* @param plugin Candidate plugin object.
+* @returns Attached Muon options, if present.
+*/
+var getMuonVitePluginOptions = (plugin) => {
+	if (!isRecord(plugin)) return;
+	const options = plugin[muonVitePluginOptionsSymbol];
+	return isMuonVitePluginOptions(options) ? options : void 0;
+};
+/**
+* Resolves nested Vite plugin option values into a flat list.
+*
+* @param pluginOptions Raw `plugins` field from a Vite config.
+* @returns Flat plugin object list.
+*/
+var flattenVitePluginOptions = async (pluginOptions) => {
+	const resolvedValue = await pluginOptions;
+	if (resolvedValue === null || resolvedValue === void 0 || !resolvedValue) return [];
+	if (Array.isArray(resolvedValue)) return (await Promise.all(resolvedValue.map((entry) => flattenVitePluginOptions(entry)))).flat();
+	return [resolvedValue];
+};
+//#endregion
+//#region src/build-sequence.ts
+/**
+* Environment variable used to prevent the Vite plugin build hook from running
+* when a CLI command owns the Muon build sequence.
+*/
+var muonBuildSequenceSuppressViteBuildEnvironmentKey = "MUON_SUPPRESS_VITE_MUON_BUILD";
+var isMissingVitePackageError = (error) => {
+	const candidate = error;
+	return candidate.code === "ERR_MODULE_NOT_FOUND" && typeof candidate.message === "string" && candidate.message.includes("vite");
+};
+var resolveViteOutputDirectory = (config) => {
+	return (0, node_path.isAbsolute)(config.build.outDir) ? config.build.outDir : (0, node_path.resolve)(config.root, config.build.outDir);
+};
+var findMuonVitePluginOptions = async (plugins) => {
+	const muonPlugins = (await flattenVitePluginOptions(plugins)).map((plugin) => getMuonVitePluginOptions(plugin)).filter((pluginOptions) => pluginOptions !== void 0);
+	if (muonPlugins.length > 1) throw new Error("Multiple muon() plugin definitions were found in vite.config.*.");
+	return muonPlugins[0];
+};
+/**
+* Loads Vite configuration only far enough to discover whether a Muon plugin
+* controls the build sequence.
+*/
+var loadMuonBuildSequenceProject = async (cwd) => {
+	const resolvedCwd = (0, node_path.resolve)(cwd);
+	let vite;
+	try {
+		vite = await import("vite");
+	} catch (error) {
+		if (isMissingVitePackageError(error)) return {
+			root: resolvedCwd,
+			viteBuildRoot: resolvedCwd,
+			viteOutputDirectory: void 0,
+			pluginOptions: void 0
+		};
+		throw error;
+	}
+	const resolvedConfig = await vite.resolveConfig({
+		root: resolvedCwd,
+		logLevel: "silent"
+	}, "build", "production", "production");
+	const pluginOptions = await findMuonVitePluginOptions(resolvedConfig.plugins);
+	if (pluginOptions === void 0) return {
+		root: resolvedCwd,
+		viteBuildRoot: resolvedCwd,
+		viteOutputDirectory: void 0,
+		pluginOptions: void 0
+	};
+	return {
+		root: resolvedConfig.root,
+		viteBuildRoot: resolvedCwd,
+		viteOutputDirectory: resolveViteOutputDirectory(resolvedConfig),
+		pluginOptions
+	};
+};
+/**
+* Returns Muon build options from a Muon Vite plugin declaration.
+*/
+var resolveMuonViteBuildOptions = (pluginOptions) => {
+	if (pluginOptions?.build === false) throw new Error("Muon build is disabled by muon({ build: false }).");
+	return typeof pluginOptions?.build === "object" ? pluginOptions.build : {};
+};
+var runViteBuild = async (root) => {
+	const vite = await import("vite");
+	const previous = process.env[muonBuildSequenceSuppressViteBuildEnvironmentKey];
+	process.env[muonBuildSequenceSuppressViteBuildEnvironmentKey] = "1";
+	try {
+		await vite.build({
+			root,
+			logLevel: "silent"
+		});
+	} finally {
+		if (previous === void 0) delete process.env[muonBuildSequenceSuppressViteBuildEnvironmentKey];
+		else process.env[muonBuildSequenceSuppressViteBuildEnvironmentKey] = previous;
+	}
+};
+var hasExplicitTargets = (options) => options.targets !== void 0 && options.targets.length > 0;
+var copyDefinedBuildOptions = (output, input, usesViteAssets) => {
+	if (input.assetSourcePath !== void 0) {
+		if (usesViteAssets) throw new Error("--assets cannot be used when a muon() Vite plugin provides the build sequence.");
+		output.assetSourcePath = input.assetSourcePath;
+	}
+	if (input.assetPrefix !== void 0) output.assetPrefix = input.assetPrefix;
+	if (input.targets !== void 0 && input.targets.length > 0) {
+		output.targets = input.targets;
+		if (input.allTargets === void 0) output.allTargets = false;
+	}
+	if (input.allTargets !== void 0) output.allTargets = input.allTargets;
+	if (input.appName !== void 0) output.appName = input.appName;
+	if (input.appId !== void 0) output.appId = input.appId;
+	if (input.outputRoot !== void 0) output.outputRoot = input.outputRoot;
+	if (input.configPath !== void 0) output.configPath = input.configPath;
+	if (input.iconPath !== void 0) output.iconPath = input.iconPath;
+	if (input.windowsResource !== void 0) {
+		const windowsResource = mergeMuonWindowsResourceOptions(input.windowsResource, output.windowsResource);
+		if (windowsResource !== void 0) output.windowsResource = windowsResource;
+	}
+	if (input.linuxDesktop !== void 0) {
+		const linuxDesktop = mergeMuonLinuxDesktopOptions(input.linuxDesktop, output.linuxDesktop);
+		if (linuxDesktop !== void 0) output.linuxDesktop = linuxDesktop;
+	}
+	if (input.packageDirectory !== void 0) output.packageDirectory = input.packageDirectory;
+	if (input.assetSalt !== void 0) output.assetSalt = input.assetSalt;
+};
+/**
+* Runs the project build sequence used by `muon build` and `muon pack`.
+*/
+var runMuonBuildSequence = async (options = {}, loadedProject) => {
+	const project = loadedProject ?? await loadMuonBuildSequenceProject(options.root ?? process.cwd());
+	const pluginBuildOptions = resolveMuonViteBuildOptions(project.pluginOptions);
+	const usesViteAssets = project.pluginOptions !== void 0;
+	const buildOptions = { root: project.root };
+	if (usesViteAssets) {
+		if (project.viteOutputDirectory === void 0) throw new Error("Vite output directory could not be resolved.");
+		Object.assign(buildOptions, pluginBuildOptions);
+		buildOptions.assetSourcePath = project.viteOutputDirectory;
+		buildOptions.assetPrefix = "main";
+		await runViteBuild(project.viteBuildRoot);
+	} else if (options.defaultAllTargets !== void 0 && options.allTargets === void 0 && !hasExplicitTargets(options)) buildOptions.allTargets = options.defaultAllTargets;
+	copyDefinedBuildOptions(buildOptions, options, usesViteAssets);
+	return await buildMuonApp(buildOptions);
+};
+//#endregion
 //#region src/vite-internals.ts
 var resolveFromRoot = (root, path) => (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(root, path);
 var moduleDirectory = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
@@ -2323,7 +3618,7 @@ var getWebSocketOrigin = (startUrl) => {
 	else if (url.protocol === "http:") url.protocol = "ws:";
 	return url.origin;
 };
-var createMuonOverrideConfig = (startUrl, enableDebugger) => {
+var createMuonOverrideConfig = (startUrl, enableDebugger, runtimePluginConfig) => {
 	const origin = new URL(startUrl).origin;
 	return {
 		...enableDebugger ? { cdp: { enable: true } } : {},
@@ -2332,19 +3627,22 @@ var createMuonOverrideConfig = (startUrl, enableDebugger) => {
 			...enableDebugger ? { keybind: {
 				devtools: "f12",
 				recycle: "ctrl+f12"
-			} } : {},
-			plugin: { allow: [`${origin}/**`] }
+			} } : {}
+		},
+		plugin: {
+			...runtimePluginConfig,
+			pages: [`${origin}/**`]
 		},
 		network: { allow: [`${origin}/**`, `${getWebSocketOrigin(startUrl)}/**`] }
 	};
 };
-var writeMuonOverrideConfig = (server, overrideConfigPath, enableDebugger) => {
+var writeMuonOverrideConfig = (server, overrideConfigPath, pluginOptions, getRuntimePluginConfig) => {
 	const startUrl = getBaseUrl(server);
 	if (startUrl === void 0) {
 		server.config.logger.warn("Muon Vite plugin could not resolve a Vite URL.");
 		return false;
 	}
-	(0, node_fs.writeFileSync)(overrideConfigPath, `${JSON.stringify(createMuonOverrideConfig(startUrl, enableDebugger), null, 2)}\n`);
+	(0, node_fs.writeFileSync)(overrideConfigPath, `${JSON.stringify(createMuonOverrideConfig(startUrl, pluginOptions.enableDebugger !== false, getRuntimePluginConfig()), null, 2)}\n`);
 	return true;
 };
 var createRuntimePaths = async (server, stagePath, platform, projectConfigPath) => {
@@ -2407,7 +3705,7 @@ var launchMuon = (paths, platform, server) => {
 	});
 	child.unref();
 };
-var startMuonViteBrowserBridge = async ({ server, pluginOptions, platform, architecture, environment }) => {
+var startMuonViteBrowserBridge = async ({ server, pluginOptions, getRuntimePluginConfig, platform, architecture, environment }) => {
 	await ensureMuonGitignoreEntry(server.config.root);
 	if (pluginOptions.open === false || server.httpServer === null) return;
 	const target = getDefaultMuonPrepareTarget(platform, architecture);
@@ -2427,7 +3725,7 @@ var startMuonViteBrowserBridge = async ({ server, pluginOptions, platform, archi
 		environment,
 		cwd: server.config.root
 	});
-	if (preparedRuntime.stagePath === void 0) throw new Error("muon-prepare did not return a staged runtime path.");
+	if (preparedRuntime.stagePath === void 0) throw new Error("muon-builder did not return a staged runtime path.");
 	const paths = await createRuntimePaths(server, preparedRuntime.stagePath, platform, await resolveProjectConfigPath(server));
 	await writeLaunchScript(paths, platform);
 	let cleanupPromise = void 0;
@@ -2453,63 +3751,8 @@ var startMuonViteBrowserBridge = async ({ server, pluginOptions, platform, archi
 		cleanup();
 	});
 	server.httpServer.once("listening", () => {
-		if (writeMuonOverrideConfig(server, paths.overrideConfigPath, pluginOptions.enableDebugger !== false)) launchMuon(paths, platform, server);
-	});
-};
-//#endregion
-//#region src/vite-options.ts
-/**
-* Metadata symbol used to recover `muon()` plugin options from `vite.config.*`.
-*/
-var muonVitePluginOptionsSymbol = Symbol.for("muon.vite.plugin.options");
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
-var isMuonViteBuildOptions = (value) => {
-	if (!isRecord(value)) return false;
-	return (value.targets === void 0 || isStringArray(value.targets)) && (value.allTargets === void 0 || typeof value.allTargets === "boolean") && (value.appName === void 0 || typeof value.appName === "string") && (value.appId === void 0 || typeof value.appId === "string") && (value.outputRoot === void 0 || typeof value.outputRoot === "string") && (value.configPath === void 0 || typeof value.configPath === "string") && (value.packageDirectory === void 0 || typeof value.packageDirectory === "string") && (value.assetSalt === void 0 || value.assetSalt instanceof Uint8Array);
-};
-var isMuonVitePluginOptions = (value) => {
-	if (!isRecord(value)) return false;
-	return (value.muonPath === void 0 || typeof value.muonPath === "string") && (value.cefPath === void 0 || typeof value.cefPath === "string") && (value.stagePath === void 0 || typeof value.stagePath === "string") && (value.open === void 0 || typeof value.open === "boolean") && (value.enableDebugger === void 0 || typeof value.enableDebugger === "boolean") && (value.build === void 0 || typeof value.build === "boolean" || isMuonViteBuildOptions(value.build));
-};
-/**
-* Attaches raw Muon Vite plugin options to a plugin instance.
-*
-* @param plugin Plugin object.
-* @param options Raw plugin options.
-* @returns Plugin object with internal Muon metadata.
-*/
-var attachMuonVitePluginOptions = (plugin, options) => {
-	Object.defineProperty(plugin, muonVitePluginOptionsSymbol, {
-		configurable: false,
-		enumerable: false,
-		value: { ...options },
-		writable: false
+		if (writeMuonOverrideConfig(server, paths.overrideConfigPath, pluginOptions, getRuntimePluginConfig)) launchMuon(paths, platform, server);
 	});
-	return plugin;
-};
-/**
-* Reads raw Muon Vite plugin options from a plugin instance.
-*
-* @param plugin Candidate plugin object.
-* @returns Attached Muon options, if present.
-*/
-var getMuonVitePluginOptions = (plugin) => {
-	if (!isRecord(plugin)) return;
-	const options = plugin[muonVitePluginOptionsSymbol];
-	return isMuonVitePluginOptions(options) ? options : void 0;
-};
-/**
-* Resolves nested Vite plugin option values into a flat list.
-*
-* @param pluginOptions Raw `plugins` field from a Vite config.
-* @returns Flat plugin object list.
-*/
-var flattenVitePluginOptions = async (pluginOptions) => {
-	const resolvedValue = await pluginOptions;
-	if (resolvedValue === null || resolvedValue === void 0 || !resolvedValue) return [];
-	if (Array.isArray(resolvedValue)) return (await Promise.all(resolvedValue.map((entry) => flattenVitePluginOptions(entry)))).flat();
-	return [resolvedValue];
 };
 //#endregion
 Object.defineProperty(exports, "__toESM", {
@@ -2518,6 +3761,12 @@ Object.defineProperty(exports, "__toESM", {
 		return __toESM;
 	}
 });
+Object.defineProperty(exports, "allMuonTargets", {
+	enumerable: true,
+	get: function() {
+		return allMuonTargets;
+	}
+});
 Object.defineProperty(exports, "attachMuonVitePluginOptions", {
 	enumerable: true,
 	get: function() {
@@ -2530,6 +3779,18 @@ Object.defineProperty(exports, "buildMuonApp", {
 		return buildMuonApp;
 	}
 });
+Object.defineProperty(exports, "createLinuxDesktopEntry", {
+	enumerable: true,
+	get: function() {
+		return createLinuxDesktopEntry;
+	}
+});
+Object.defineProperty(exports, "createWindowsIconFromPngFile", {
+	enumerable: true,
+	get: function() {
+		return createWindowsIconFromPngFile;
+	}
+});
 Object.defineProperty(exports, "embedMuonConfigInBootstrapFile", {
 	enumerable: true,
 	get: function() {
@@ -2560,6 +3821,12 @@ Object.defineProperty(exports, "flattenVitePluginOptions", {
 		return flattenVitePluginOptions;
 	}
 });
+Object.defineProperty(exports, "getDefaultMuonBuildTarget", {
+	enumerable: true,
+	get: function() {
+		return getDefaultMuonBuildTarget;
+	}
+});
 Object.defineProperty(exports, "getDefaultMuonPrepareTarget", {
 	enumerable: true,
 	get: function() {
@@ -2584,6 +3851,48 @@ Object.defineProperty(exports, "getMuonVitePluginOptions", {
 		return getMuonVitePluginOptions;
 	}
 });
+Object.defineProperty(exports, "loadMuonBuildSequenceProject", {
+	enumerable: true,
+	get: function() {
+		return loadMuonBuildSequenceProject;
+	}
+});
+Object.defineProperty(exports, "mergeMuonLinuxDesktopOptions", {
+	enumerable: true,
+	get: function() {
+		return mergeMuonLinuxDesktopOptions;
+	}
+});
+Object.defineProperty(exports, "mergeMuonWindowsResourceOptions", {
+	enumerable: true,
+	get: function() {
+		return mergeMuonWindowsResourceOptions;
+	}
+});
+Object.defineProperty(exports, "muonBuildSequenceSuppressViteBuildEnvironmentKey", {
+	enumerable: true,
+	get: function() {
+		return muonBuildSequenceSuppressViteBuildEnvironmentKey;
+	}
+});
+Object.defineProperty(exports, "normalizeMuonTarget", {
+	enumerable: true,
+	get: function() {
+		return normalizeMuonTarget;
+	}
+});
+Object.defineProperty(exports, "quoteDesktopExecArgument", {
+	enumerable: true,
+	get: function() {
+		return quoteDesktopExecArgument;
+	}
+});
+Object.defineProperty(exports, "readMuonConfigForWindowsResource", {
+	enumerable: true,
+	get: function() {
+		return readMuonConfigForWindowsResource;
+	}
+});
 Object.defineProperty(exports, "require_dist", {
 	enumerable: true,
 	get: function() {
@@ -2596,6 +3905,24 @@ Object.defineProperty(exports, "resolveMuonRuntimePath", {
 		return resolveMuonRuntimePath;
 	}
 });
+Object.defineProperty(exports, "resolveMuonViteBuildOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveMuonViteBuildOptions;
+	}
+});
+Object.defineProperty(exports, "resolveMuonWindowsResource", {
+	enumerable: true,
+	get: function() {
+		return resolveMuonWindowsResource;
+	}
+});
+Object.defineProperty(exports, "runMuonBuildSequence", {
+	enumerable: true,
+	get: function() {
+		return runMuonBuildSequence;
+	}
+});
 Object.defineProperty(exports, "runMuonPrepare", {
 	enumerable: true,
 	get: function() {
@@ -2608,5 +3935,17 @@ Object.defineProperty(exports, "startMuonViteBrowserBridge", {
 		return startMuonViteBrowserBridge;
 	}
 });
+Object.defineProperty(exports, "updateWindowsPeIconResource", {
+	enumerable: true,
+	get: function() {
+		return updateWindowsPeIconResource;
+	}
+});
+Object.defineProperty(exports, "updateWindowsPeResources", {
+	enumerable: true,
+	get: function() {
+		return updateWindowsPeResources;
+	}
+});
 
-//# sourceMappingURL=vite-options-FFh0NWUa.cjs.map
+//# sourceMappingURL=vite-internals-HXgH7b5M.cjs.map