muon-ui 0.7.0 → 0.8.0

package/dist/vite.mjs

@@ -1,13 +1,13 @@
 /*!
 * name: muon-ui
-* version: 0.7.0
+* version: 0.8.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: 9bb6148e155dab16c4ca441073b144e21981b038
 */
-import { basename, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { constants, writeFileSync } from "node:fs";
 import { access, chmod, copyFile, cp, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { createHash, randomBytes } from "node:crypto";
@@ -15,6 +15,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import __screwUpDefaultImportModule0 from "adm-zip";
 import { spawn } from "node:child_process";
+import * as __screwUpDefaultImportModule0$1 from "sharp";
 //#region \0rolldown/runtime.js
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 //#endregion
@@ -1292,7 +1293,7 @@ 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 isHexString = (value) => value.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(value);
 var decodeHexString = (value) => {
@@ -1325,7 +1326,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]),
@@ -1439,7 +1440,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$4 = async (path) => {
 	try {
 		return (await stat(path)).isFile();
 	} catch {
@@ -1455,10 +1456,10 @@ var resolveMuonConfigInputPath = async (configPath) => {
 			"muon.json"
 		]) {
 			const candidate = join(directory, fileName);
-			if (await fileExists$2(candidate)) return candidate;
+			if (await fileExists$4(candidate)) return candidate;
 		}
 	}
-	if (!await fileExists$2(configPath)) throw new Error(`muon config does not exist: ${configPath}`);
+	if (!await fileExists$4(configPath)) throw new Error(`muon config does not exist: ${configPath}`);
 	return configPath;
 };
 var readMuonConfigInput = async (configPath) => {
@@ -1571,7 +1572,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: "",
@@ -1586,7 +1587,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: "",
@@ -1601,7 +1602,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: "",
@@ -1616,7 +1617,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",
@@ -1636,7 +1637,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",
@@ -1707,8 +1708,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 : dirname(fileURLToPath(import.meta.url));
+var getBuilderExecutableName = (platform) => platform === "win32" ? "muon-builder.exe" : "muon-builder";
+var moduleDirectory$4 = typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
 var canExecute = async (path) => {
 	try {
 		await access(path, constants.X_OK);
@@ -1717,12 +1718,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 = [join(moduleDirectory$2, "native", target, executableName), join(moduleDirectory$2, "..", "dist", "native", target, executableName)];
+	const candidates = [join(moduleDirectory$4, "native", target, executableName), join(moduleDirectory$4, "..", "dist", "native", target, executableName)];
 	for (const candidate of candidates) if (await canExecute(candidate)) return candidate;
 	return candidates[0] ?? executableName;
 };
@@ -1741,14 +1742,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 = 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 = spawn(await resolveMuonBuilderExecutable(options), [...options.args], {
 		cwd: options.cwd,
 		env: options.environment,
 		stdio: [
@@ -1761,22 +1848,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,
@@ -1784,6 +1895,675 @@ 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/windows-icon.ts
+var sharp = __resolveDefaultExport$1(__screwUpDefaultImportModule0$1, true);
+globalThis.__screwUpIsInCJS_27e672935538 = false;
+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(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 readFile(sourcePath), sourcePath);
+	await mkdir(dirname(outputPath), { recursive: true });
+	await 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(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(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/windows-resource.ts
+var defaultLanguage = 1033;
+var defaultCodePage = 1200;
+var moduleDirectory$3 = typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
+/**
+* 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(input.root);
+	const sources = [
+		createOptionsSource$1(input.options, input.root, "windowsResource"),
+		readConfigWindowsResourceSource(input.muonConfig, input.muonConfigDirectory, "muon.json"),
+		createProjectSource(projectJson, input.root),
+		createPackageSource(input.packageJson, 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 resolveIconPath$1(sources, 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 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) => {
+	if (!await isWindowsPeExecutable(input.executablePath)) return false;
+	const mode = (await stat(input.executablePath)).mode & 511;
+	const tempDirectory = await mkdtemp(join(tmpdir(), "muon-windows-resource-"));
+	const updatesJsonPath = join(tempDirectory, "updates.json");
+	const outputPath = join(tempDirectory, "output.exe");
+	const iconPath = input.resource.iconPath === void 0 ? void 0 : join(tempDirectory, "icon.ico");
+	try {
+		if (input.resource.iconPath !== void 0 && iconPath !== void 0) await createWindowsIconFromPngFile(input.resource.iconPath, iconPath);
+		await writeFile(updatesJsonPath, `${JSON.stringify(createEngraverUpdate(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 copyFile(outputPath, input.executablePath);
+		await chmod(input.executablePath, mode === 0 ? 493 : mode);
+		return true;
+	} finally {
+		await 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: iconPath === void 0 ? [] : [{
+			id: 1,
+			language: resource.language,
+			path: iconPath
+		}]
+	};
+};
+var readProjectJson = async (root) => {
+	const projectJsonPath = join(root, "project.json");
+	if (!await fileExists$3(projectJsonPath)) return {};
+	return await readJsonObjectFile$1(projectJsonPath, "project.json");
+};
+var readJsonObjectFile$1 = async (filePath, label) => {
+	const parsed = (0, import_dist.parse)(await 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, "iconPath", topLevel, "iconPath");
+	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 resolveIconPath$1 = async (sources, defaultIconPath) => {
+	for (const source of sources) {
+		const value = source.options.iconPath;
+		if (value !== void 0 && value.trim() !== "") {
+			const iconPath = resolveResourcePath$1(source.directory, value);
+			await assertIconPath$1(iconPath, true);
+			return iconPath;
+		}
+	}
+	if (defaultIconPath !== void 0 && await fileExists$3(defaultIconPath)) {
+		await assertIconPath$1(defaultIconPath, false);
+		return defaultIconPath;
+	}
+};
+var assertIconPath$1 = async (iconPath, required) => {
+	if (extname(iconPath).toLowerCase() !== ".png") throw new Error(`Windows resource icon must be a .png file: ${iconPath}`);
+	if (required && !await fileExists$3(iconPath)) throw new Error(`Windows resource icon does not exist: ${iconPath}`);
+	if (await fileExists$3(iconPath)) await createNormalizedMuonIconPngData(await readFile(iconPath), iconPath);
+};
+var resolveDefaultWindowsIcon = async (packageDirectory) => {
+	const candidates = [
+		join(resolve(packageDirectory), "native", "muon-bootstrap.png"),
+		join(moduleDirectory$3, "native", "muon-bootstrap.png"),
+		join(moduleDirectory$3, "..", "dist", "native", "muon-bootstrap.png"),
+		join(moduleDirectory$3, "..", "..", "images", "muon-bootstrap-256.png")
+	];
+	for (const candidate of candidates) if (await fileExists$3(candidate)) return candidate;
+};
+var resolveResourcePath$1 = (directory, path) => {
+	return isAbsolute(path) ? 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 access(path, 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 : dirname(fileURLToPath(import.meta.url));
+/**
+* Resolves Linux desktop integration metadata from options, config files, and
+* package metadata.
+*/
+var resolveMuonLinuxDesktop = async (input) => {
+	const sources = [createOptionsSource(input.options, input.root, "linuxDesktop"), readConfigLinuxDesktopSource(input.muonConfig, input.muonConfigDirectory, "muon.json")].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 resolveIconPath(sources, 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 readFile(desktop.iconPath), desktop.iconPath, "Linux desktop icon");
+	await writeFile(join(outputPath, desktop.iconFileName), iconData);
+	await writeFile(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`);
+};
+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 resolveIconPath = async (sources, 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;
+		}
+	}
+	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 (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 readFile(iconPath), iconPath, "Linux desktop icon");
+};
+var resolveDefaultLinuxDesktopIcon = async (packageDirectory) => {
+	const candidates = [
+		join(resolve(packageDirectory), "native", "muon-bootstrap.png"),
+		join(moduleDirectory$2, "native", "muon-bootstrap.png"),
+		join(moduleDirectory$2, "..", "dist", "native", "muon-bootstrap.png"),
+		join(moduleDirectory$2, "..", "..", "images", "muon-bootstrap-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 resolveResourcePath = (directory, path) => {
+	return isAbsolute(path) ? path : resolve(directory, path);
+};
+var fileExists$2 = async (path) => {
+	try {
+		await access(path, 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(__screwUpDefaultImportModule0, false);
@@ -1844,17 +2624,49 @@ var buildMuonApp = async (options = {}) => {
 	const appId = resolveAppId(packageJson, options.appId);
 	const buildConfig = await readBuildConfig(root, options.configPath);
 	const assetInput = resolveAssetInput(root, options.assetSourcePath, options.assetPrefix, buildConfig);
+	const windowsResource = await resolveMuonWindowsResource({
+		root,
+		packageDirectory,
+		packageJson,
+		muonConfig: buildConfig.config,
+		muonConfigDirectory: buildConfig.directory,
+		options: options.windowsResource,
+		defaults: {
+			productName: appName,
+			fileDescription: appName,
+			companyName: "Unknown",
+			version: "0.0.0",
+			copyright: void 0
+		}
+	});
+	const linuxDesktop = await resolveMuonLinuxDesktop({
+		root,
+		packageDirectory,
+		muonConfig: buildConfig.config,
+		muonConfigDirectory: buildConfig.directory,
+		options: options.linuxDesktop,
+		defaults: {
+			desktopId: appId,
+			name: resolveLinuxDesktopDefaultName(packageJson, appName),
+			comment: resolvePackageDescription(packageJson),
+			categories: ["Utility"],
+			startupNotify: true
+		}
+	});
 	const salt = Buffer.from(options.assetSalt ?? randomBytes(assetSaltByteLength));
 	const results = [];
 	for (const target of targets) {
 		const result = await buildMuonTarget({
 			packageDirectory,
+			root,
 			outputRoot,
 			appName,
 			appId,
 			target,
 			assetInput,
 			sourceConfig: buildConfig.config,
+			windowsResource,
+			linuxDesktop,
 			salt
 		});
 		results.push(result);
@@ -1912,6 +2724,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 {
@@ -1985,7 +2799,7 @@ var buildMuonTarget = async (input) => {
 	await copyFile(sourceBootstrapPath, launcherPath);
 	await chmod(launcherPath, executableMode);
 	const asset = await writeAssetArchive(input.assetInput, assetZipPath, input.salt);
-	const embeddedConfig = createEmbeddedConfig(input.sourceConfig, asset, input.appId);
+	const embeddedConfig = createEmbeddedConfig(input.sourceConfig, asset, input.appId, input.linuxDesktop.desktopId);
 	await withTemporaryConfig(embeddedConfig, async (configPath) => {
 		await embedMuonConfigInRuntime({
 			runtimePath: outputPath,
@@ -1998,13 +2812,21 @@ var buildMuonTarget = async (input) => {
 			outputPath: void 0
 		});
 	});
+	if (descriptor.os === "windows") 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
+		embeddedConfig,
+		...descriptor.os === "linux" ? { linuxDesktop: input.linuxDesktop } : {}
 	};
 };
 var verifyTargetInputs = async (input) => {
@@ -2079,13 +2901,13 @@ 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) => {
 	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.");
 	return {
-		...sourceConfig,
+		...stripBuildOnlyLinuxDesktopConfig(stripBuildOnlyWindowsResourceConfig(sourceConfig)),
 		asset: {
 			...sourceAsset ?? {},
 			sourcePath: appConfigSourcePath,
@@ -2094,7 +2916,8 @@ var createEmbeddedConfig = (sourceConfig, asset, appId) => {
 		},
 		bootstrap: {
 			...sourceBootstrap ?? {},
-			appId
+			appId,
+			desktopId
 		}
 	};
 };
@@ -2142,7 +2965,7 @@ var getErrorMessage$1 = (error) => error instanceof Error ? error.message : Stri
 //#region src/gitignore.ts
 var muonGitignoreEntries = [
 	".muon/",
-	"dist-muon-*/",
+	"dist-muon/",
 	"artifacts/"
 ];
 var muonGitignoreEntryAliases = {
@@ -2152,11 +2975,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/",
@@ -2403,7 +3228,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;
@@ -2456,12 +3281,12 @@ var attachMuonVitePluginOptions = (plugin, options) => {
 };
 //#endregion
 //#region src/vite.ts
-var suppressViteMuonBuildEnvironmentKey = "MUON_SUPPRESS_VITE_MUON_BUILD";
 /**
 * Creates a Vite plugin that launches Muon during Vite dev startup.
 *
 * @param options Muon plugin options used for development startup and build.
 * @returns Vite plugin instance.
+* @defaultValue `options` defaults to `{}`.
 */
 var muon = (options = {}) => {
 	let resolvedConfig = void 0;
@@ -2485,7 +3310,7 @@ var muon = (options = {}) => {
 		},
 		closeBundle: async () => {
 			if (resolvedConfig === void 0 || resolvedConfig.command !== "build") return;
-			if (process.env[suppressViteMuonBuildEnvironmentKey] === "1") return;
+			if (process.env["MUON_SUPPRESS_VITE_MUON_BUILD"] === "1") return;
 			if (options.build === false) return;
 			const buildOptions = typeof options.build === "object" ? options.build : {};
 			await buildMuonApp(createMuonBuildOptions(resolvedConfig, buildOptions));
@@ -2518,6 +3343,8 @@ var createMuonBuildOptions = (config, buildOptions) => {
 	if (buildOptions.appId !== void 0) options.appId = buildOptions.appId;
 	if (buildOptions.outputRoot !== void 0) options.outputRoot = buildOptions.outputRoot;
 	if (buildOptions.configPath !== void 0) options.configPath = buildOptions.configPath;
+	if (buildOptions.windowsResource !== void 0) options.windowsResource = buildOptions.windowsResource;
+	if (buildOptions.linuxDesktop !== void 0) options.linuxDesktop = buildOptions.linuxDesktop;
 	if (buildOptions.packageDirectory !== void 0) options.packageDirectory = buildOptions.packageDirectory;
 	if (buildOptions.assetSalt !== void 0) options.assetSalt = buildOptions.assetSalt;
 	return options;