muon-ui 0.7.0 → 0.9.0

package/dist/cli.cjs

@@ -1,23 +1,24 @@
 #!/usr/bin/env node
 /*!
 * 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
 */
-const require_vite_options = require("./vite-options-FFh0NWUa.cjs");
+const require_vite_internals = require("./vite-internals-HXgH7b5M.cjs");
 let commander = require("commander");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 let adm_zip = require("adm-zip");
-adm_zip = require_vite_options.__toESM(adm_zip, 1);
+adm_zip = require_vite_internals.__toESM(adm_zip, 1);
+let tar_vern = require("tar-vern");
 //#region src/dev.ts
-var import_dist = require_vite_options.require_dist();
+var import_dist = require_vite_internals.require_dist();
 var muonRecycleExitCode = 88;
 var defaultProjectConfigFileNames = [
 	"muon.json5",
@@ -41,16 +42,16 @@ var directoryExists = async (path) => {
 		return false;
 	}
 };
-var isMissingVitePackageError$1 = (error) => {
+var isMissingVitePackageError = (error) => {
 	const candidate = error;
 	return candidate.code === "ERR_MODULE_NOT_FOUND" && typeof candidate.message === "string" && candidate.message.includes("vite");
 };
-var loadViteMuonOptions$1 = async (cwd) => {
+var loadViteMuonOptions = async (cwd) => {
 	let vite;
 	try {
 		vite = await import("vite");
 	} catch (error) {
-		if (isMissingVitePackageError$1(error)) return {
+		if (isMissingVitePackageError(error)) return {
 			root: (0, node_path.resolve)(cwd),
 			pluginOptions: void 0
 		};
@@ -68,7 +69,7 @@ var loadViteMuonOptions$1 = async (cwd) => {
 	};
 	const config = loaded.config;
 	const root = typeof config.root === "string" ? (0, node_path.resolve)(cwd, config.root) : (0, node_path.resolve)(cwd);
-	const muonPlugins = (await require_vite_options.flattenVitePluginOptions(config.plugins)).map((plugin) => require_vite_options.getMuonVitePluginOptions(plugin)).filter((pluginOptions) => pluginOptions !== void 0);
+	const muonPlugins = (await require_vite_internals.flattenVitePluginOptions(config.plugins)).map((plugin) => require_vite_internals.getMuonVitePluginOptions(plugin)).filter((pluginOptions) => pluginOptions !== void 0);
 	if (muonPlugins.length > 1) throw new Error("Multiple muon() plugin definitions were found in vite.config.*.");
 	return {
 		root,
@@ -129,9 +130,9 @@ var assertDevelopmentAssetDirectory = async (assetSourcePath) => {
 	try {
 		await (0, node_fs_promises.access)(assetSourcePath, node_fs.constants.F_OK);
 	} catch {
-		throw new Error(`Muon dev asset source does not exist: ${assetSourcePath}`);
+		throw new Error(`Muon run asset source does not exist: ${assetSourcePath}`);
 	}
-	throw new Error(`Muon dev asset source must be a directory: ${assetSourcePath}`);
+	throw new Error(`Muon run asset source must be a directory: ${assetSourcePath}`);
 };
 var resolveAssetSource = async (root, assetSourcePath, projectConfig) => {
 	const configuredAssetSourcePath = readConfigAssetSourcePath(projectConfig.config);
@@ -197,14 +198,14 @@ var runMuonExecutable = async (muonExecutablePath, configPaths, environment) =>
 * @returns Development startup result after the Muon process exits.
 */
 var runMuonDev = async (options = {}) => {
-	const loadedViteOptions = await loadViteMuonOptions$1((0, node_path.resolve)(options.root ?? process.cwd()));
+	const loadedViteOptions = await loadViteMuonOptions((0, node_path.resolve)(options.root ?? process.cwd()));
 	const root = loadedViteOptions.root;
 	const pluginOptions = loadedViteOptions.pluginOptions;
 	const platform = options.platform ?? process.platform;
 	const architecture = options.architecture ?? process.arch;
 	const environment = options.environment ?? process.env;
-	const target = require_vite_options.getDefaultMuonPrepareTarget(platform, architecture);
-	const muonPath = require_vite_options.resolveMuonRuntimePath({
+	const target = require_vite_internals.getDefaultMuonPrepareTarget(platform, architecture);
+	const muonPath = require_vite_internals.resolveMuonRuntimePath({
 		root,
 		target,
 		muonPath: options.muonPath ?? pluginOptions?.muonPath
@@ -214,9 +215,9 @@ var runMuonDev = async (options = {}) => {
 	const enableDebugger = options.enableDebugger ?? pluginOptions?.enableDebugger ?? true;
 	const projectConfig = await resolveProjectConfig(root, options.configPath);
 	const asset = await resolveAssetSource(root, options.assetSourcePath, projectConfig);
-	const overrideConfigPath = (0, node_path.join)(root, ".muon", "dev", "muon.dev.json");
-	await require_vite_options.ensureMuonGitignoreEntry(root);
-	const preparedRuntime = await require_vite_options.runMuonPrepare({
+	const overrideConfigPath = (0, node_path.join)(root, ".muon", "run", "muon.run.json");
+	await require_vite_internals.ensureMuonGitignoreEntry(root);
+	const preparedRuntime = await require_vite_internals.runMuonPrepare({
 		muonPath,
 		cefPath,
 		stageDir: stagePath,
@@ -228,9 +229,9 @@ var runMuonDev = async (options = {}) => {
 		environment,
 		cwd: 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.");
 	await writeMuonDevOverrideConfig(overrideConfigPath, createMuonDevOverrideConfig(asset.overrideAssetSourcePath, enableDebugger));
-	const muonExecutablePath = require_vite_options.getMuonExecutablePath(preparedRuntime.stagePath, platform);
+	const muonExecutablePath = require_vite_internals.getMuonExecutablePath(preparedRuntime.stagePath, platform);
 	const exitCode = await runMuonExecutable(muonExecutablePath, [...projectConfig.configPath === void 0 ? [] : [projectConfig.configPath], overrideConfigPath], environment);
 	return {
 		root,
@@ -269,47 +270,13 @@ function __resolveDefaultExport(module, isESM) {
 }
 var supportedPackTypes = [
 	"zip",
+	"tar.gz",
 	"deb",
 	"nsis"
 ];
 var defaultArtifactsDirectory = "artifacts";
 var defaultPackageBuildDirectory = ".muon/pack";
-var suppressViteMuonBuildEnvironmentKey = "MUON_SUPPRESS_VITE_MUON_BUILD";
 var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isMissingVitePackageError = (error) => {
-	const candidate = error;
-	return candidate.code === "ERR_MODULE_NOT_FOUND" && typeof candidate.message === "string" && candidate.message.includes("vite");
-};
-var loadViteMuonOptions = async (cwd) => {
-	let vite;
-	try {
-		vite = await import("vite");
-	} catch (error) {
-		if (isMissingVitePackageError(error)) return {
-			root: (0, node_path.resolve)(cwd),
-			pluginOptions: void 0
-		};
-		throw error;
-	}
-	const loaded = await vite.loadConfigFromFile({
-		command: "build",
-		mode: "production",
-		isPreview: false,
-		isSsrBuild: false
-	}, void 0, cwd, "silent");
-	if (loaded === null) return {
-		root: (0, node_path.resolve)(cwd),
-		pluginOptions: void 0
-	};
-	const config = loaded.config;
-	const root = typeof config.root === "string" ? (0, node_path.resolve)(cwd, config.root) : (0, node_path.resolve)(cwd);
-	const muonPlugins = (await require_vite_options.flattenVitePluginOptions(config.plugins)).map((plugin) => require_vite_options.getMuonVitePluginOptions(plugin)).filter((pluginOptions) => pluginOptions !== void 0);
-	if (muonPlugins.length > 1) throw new Error("Multiple muon() plugin definitions were found in vite.config.*.");
-	return {
-		root,
-		pluginOptions: muonPlugins[0]
-	};
-};
 var readJsonObjectFile = async (path) => {
 	const parsed = (0, import_dist.parse)(await (0, node_fs_promises.readFile)(path, "utf8"));
 	if (!isJsonObject(parsed)) throw new Error(`JSON file must contain an object: ${path}`);
@@ -341,51 +308,63 @@ var resolveMetadata = (packageJson, options) => {
 		author
 	};
 };
+var createPackMetadataPackageJson = (packageJson, metadata) => ({
+	...packageJson,
+	version: metadata.version
+});
 var normalizePackTypes = (types) => {
-	const normalized = types.flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
+	if (types === void 0) return [...supportedPackTypes];
+	const normalized = types.flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).map((value) => value === "tgz" ? "tar.gz" : value).filter((value) => value.length > 0);
 	if (normalized.length === 0) throw new Error("Specify at least one package type with --type.");
 	for (const type of normalized) if (!supportedPackTypes.includes(type)) throw new Error(`Unsupported muon pack type: ${type}`);
 	return [...new Set(normalized)];
 };
-var getPluginBuildOptions = (pluginOptions) => {
-	return typeof pluginOptions?.build === "object" ? pluginOptions.build : {};
-};
-var resolveBuildOutputDirectory = async (root) => {
-	const resolved = await (await import("vite")).resolveConfig({ root }, "build", "production", "production");
-	return (0, node_path.isAbsolute)(resolved.build.outDir) ? resolved.build.outDir : (0, node_path.resolve)(resolved.root, resolved.build.outDir);
-};
-var runViteBuild = async (root, _environment) => {
-	const vite = await import("vite");
-	const previous = process.env[suppressViteMuonBuildEnvironmentKey];
-	process.env[suppressViteMuonBuildEnvironmentKey] = "1";
-	try {
-		await vite.build({ root });
-	} finally {
-		if (previous === void 0) delete process.env[suppressViteMuonBuildEnvironmentKey];
-		else process.env[suppressViteMuonBuildEnvironmentKey] = previous;
-	}
-};
-var createBuildOptions = (root, assetSourcePath, pluginBuildOptions, options) => {
-	const buildOptions = {
-		root,
-		assetSourcePath,
-		assetPrefix: "main"
-	};
-	Object.assign(buildOptions, pluginBuildOptions);
-	if (options.targets !== void 0 && options.targets.length > 0) {
-		buildOptions.targets = options.targets;
-		buildOptions.allTargets = false;
-	} else if (options.allTargets !== void 0) buildOptions.allTargets = options.allTargets;
-	if (options.configPath !== void 0) buildOptions.configPath = options.configPath;
-	if (options.appName !== void 0) buildOptions.appName = options.appName;
-	if (options.appId !== void 0) buildOptions.appId = options.appId;
-	if (options.packageDirectory !== void 0) buildOptions.packageDirectory = options.packageDirectory;
-	return buildOptions;
-};
-var assertPackTypeSupportsTarget = (type, target) => {
-	const descriptor = require_vite_options.getMuonTargetDescriptor(target);
-	if (type === "deb" && descriptor.os !== "linux") throw new Error("deb packaging supports only Linux targets.");
-	if (type === "nsis" && descriptor.os !== "windows") throw new Error("nsis packaging supports only Windows targets.");
+var packTargetSelectorTargets = {
+	linux: [
+		"linux-amd64",
+		"linux-armhf",
+		"linux-arm64"
+	],
+	windows: ["windows-i686", "windows-amd64"],
+	amd64: ["linux-amd64", "windows-amd64"],
+	arm64: ["linux-arm64"],
+	armhf: ["linux-armhf"],
+	i686: ["windows-i686"]
+};
+var normalizePackTargetSelector = (selector) => {
+	const normalized = selector.trim().toLowerCase();
+	if (require_vite_internals.allMuonTargets.includes(normalized)) return [normalized];
+	const targets = packTargetSelectorTargets[normalized];
+	if (targets !== void 0) return targets;
+	throw new Error(`Unsupported muon pack target selector: ${selector}`);
+};
+var normalizePackTargetSelectors = (selectors) => {
+	const targets = selectors.flatMap((selector) => selector.split(",")).map((selector) => selector.trim()).filter((selector) => selector.length > 0).flatMap((selector) => normalizePackTargetSelector(selector));
+	return [...new Set(targets)];
+};
+var normalizePluginBuildTargets = (targets) => {
+	return [...new Set(targets.map((target) => require_vite_internals.normalizeMuonTarget(target, "muon pack target")))];
+};
+var resolvePackTargetCandidates = (options, pluginBuildOptions) => {
+	if (options.allTargets === true) return [...require_vite_internals.allMuonTargets];
+	if (options.targets !== void 0 && options.targets.length > 0) return normalizePackTargetSelectors(options.targets);
+	if (options.allTargets === false) return [require_vite_internals.getDefaultMuonBuildTarget()];
+	if (pluginBuildOptions.allTargets === true) return [...require_vite_internals.allMuonTargets];
+	if (pluginBuildOptions.targets !== void 0 && pluginBuildOptions.targets.length > 0) return normalizePluginBuildTargets(pluginBuildOptions.targets);
+	if (pluginBuildOptions.allTargets === false) return [require_vite_internals.getDefaultMuonBuildTarget()];
+	return [...require_vite_internals.allMuonTargets];
+};
+var packTypeSupportsTarget = (type, target) => {
+	const descriptor = require_vite_internals.getMuonTargetDescriptor(target);
+	return type === "zip" && descriptor.os === "windows" || type === "tar.gz" && descriptor.os === "linux" || type === "deb" && descriptor.os === "linux" || type === "nsis" && descriptor.os === "windows";
+};
+var createPackTargetPlan = (types, targets) => {
+	const plan = targets.map((target) => ({
+		target,
+		types: types.filter((type) => packTypeSupportsTarget(type, target))
+	})).filter((entry) => entry.types.length > 0);
+	if (plan.length === 0) throw new Error("No valid muon pack target and type combinations.");
+	return plan;
 };
 var runTool = async (executable, args, cwd, environment) => {
 	const child = (0, node_child_process.spawn)(executable, [...args], {
@@ -445,8 +424,35 @@ var packageZip = async (target, metadata, artifactsRoot) => {
 		path: outputPath
 	};
 };
+var toArchivePath = (path) => path.split(node_path.sep).join("/");
+var createTarGzEntryGenerator = async function* (directory, entryRoot) {
+	yield await (0, tar_vern.createDirectoryItem)(entryRoot, "exceptName", { directoryPath: directory });
+	const walk = async function* (currentDirectory) {
+		const entries = await (0, node_fs_promises.readdir)(currentDirectory, { withFileTypes: true });
+		entries.sort((left, right) => left.name.localeCompare(right.name));
+		for (const entry of entries) {
+			const path = (0, node_path.join)(currentDirectory, entry.name);
+			const entryName = `${entryRoot}/${toArchivePath((0, node_path.relative)(directory, path))}`;
+			if (entry.isDirectory()) {
+				yield await (0, tar_vern.createDirectoryItem)(entryName, "exceptName", { directoryPath: path });
+				yield* walk(path);
+			} else if (entry.isFile()) yield await (0, tar_vern.createReadFileItem)(entryName, path, "exceptName");
+		}
+	};
+	yield* walk(directory);
+};
+var packageTarGz = async (target, metadata, artifactsRoot) => {
+	const outputPath = (0, node_path.join)(artifactsRoot, `${metadata.packageName}-${metadata.version}-${target.target}.tar.gz`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	await (0, tar_vern.storeReaderToFile)((0, tar_vern.createTarPacker)(createTarGzEntryGenerator(target.outputPath, target.distributionDirectoryName), "gzip"), outputPath);
+	return {
+		type: "tar.gz",
+		target: target.target,
+		path: outputPath
+	};
+};
 var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot, environment) => {
-	const descriptor = require_vite_options.getMuonTargetDescriptor(target.target);
+	const descriptor = require_vite_internals.getMuonTargetDescriptor(target.target);
 	if (descriptor.os !== "linux") throw new Error(`Unsupported deb target: ${target.target}`);
 	const architecture = descriptor.arch;
 	const packageRoot = (0, node_path.join)(packageBuildRoot, "deb", `${metadata.packageName}-${target.target}`);
@@ -457,6 +463,11 @@ var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot,
 	const installedDist = (0, node_path.join)((0, node_path.join)(packageRoot, "usr", "lib", metadata.packageName), target.distributionDirectoryName);
 	await (0, node_fs_promises.mkdir)(installedDist, { recursive: true });
 	await (0, node_fs_promises.cp)(target.outputPath, installedDist, { recursive: true });
+	await (0, node_fs_promises.writeFile)((0, node_path.join)(installedDist, "muon-install.json"), `${JSON.stringify({
+		type: "deb",
+		packageName: metadata.packageName,
+		launcherPath: `/usr/bin/${metadata.packageName}`
+	}, void 0, 2)}\n`);
 	const binPath = (0, node_path.join)(packageRoot, "usr", "bin", metadata.packageName);
 	const launcherName = (0, node_path.basename)(target.launcherPath);
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(binPath), { recursive: true });
@@ -467,6 +478,18 @@ var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot,
 		""
 	].join("\n"));
 	await (0, node_fs_promises.chmod)(binPath, 493);
+	if (target.linuxDesktop === void 0) throw new Error(`Linux desktop metadata is unavailable: ${target.target}`);
+	const applicationsPath = (0, node_path.join)(packageRoot, "usr", "share", "applications", `${target.linuxDesktop.desktopId}.desktop`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(applicationsPath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(applicationsPath, require_vite_internals.createLinuxDesktopEntry({
+		desktop: target.linuxDesktop,
+		exec: `${require_vite_internals.quoteDesktopExecArgument(`/usr/bin/${metadata.packageName}`)} --muon-launch-from=normal`,
+		tryExec: `/usr/bin/${metadata.packageName}`,
+		icon: target.linuxDesktop.desktopId
+	}));
+	const iconPath = (0, node_path.join)(packageRoot, "usr", "share", "icons", "hicolor", "256x256", "apps", `${target.linuxDesktop.desktopId}.png`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(iconPath), { recursive: true });
+	await (0, node_fs_promises.cp)((0, node_path.join)(target.outputPath, target.linuxDesktop.iconFileName), iconPath);
 	const controlPath = (0, node_path.join)(packageRoot, "DEBIAN", "control");
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(controlPath), { recursive: true });
 	await (0, node_fs_promises.writeFile)(controlPath, [
@@ -491,24 +514,59 @@ var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot,
 	};
 };
 var escapeNsis = (value) => value.replaceAll("\\", "\\\\").replaceAll("\"", "$\\\"");
-var packageNsis = async (root, target, metadata, artifactsRoot, packageBuildRoot, environment) => {
-	const descriptor = require_vite_options.getMuonTargetDescriptor(target.target);
+var nsisUninstallRegistryRoot = "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall";
+var createNsisUninstallRegistryKey = (appId) => `${nsisUninstallRegistryRoot}\\${appId}`;
+var packageNsis = async (root, target, metadata, windowsResource, artifactsRoot, packageBuildRoot, environment) => {
+	const descriptor = require_vite_internals.getMuonTargetDescriptor(target.target);
 	if (descriptor.os !== "windows") throw new Error(`Unsupported nsis target: ${target.target}`);
 	const scriptPath = (0, node_path.join)(packageBuildRoot, "nsis", `${metadata.packageName}-${target.target}.nsi`);
 	const outputPath = (0, node_path.join)(artifactsRoot, `${metadata.packageName}-${metadata.version}-${descriptor.arch}-setup.exe`);
+	const launcherFileName = (0, node_path.basename)(target.launcherPath);
+	const nsisDisplayName = `${metadata.packageName} (${descriptor.arch})`;
+	const nsisInstallDirectoryName = `${metadata.packageName}-${descriptor.arch}`;
+	const uninstallRegistryKey = createNsisUninstallRegistryKey(target.runtimeAppId);
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(scriptPath), { recursive: true });
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	const iconPath = (0, node_path.join)((0, node_path.dirname)(scriptPath), `${metadata.packageName}-${target.target}.ico`);
+	await require_vite_internals.createWindowsIconFromPngFile(windowsResource.iconPath, iconPath);
 	await (0, node_fs_promises.writeFile)(scriptPath, [
 		"Unicode true",
-		`Name "${escapeNsis(metadata.packageName)}"`,
+		`Name "${escapeNsis(nsisDisplayName)}"`,
 		`OutFile "${escapeNsis(outputPath)}"`,
-		`InstallDir "$LOCALAPPDATA\\Programs\\${escapeNsis(metadata.packageName)}"`,
+		`InstallDir "$LOCALAPPDATA\\Programs\\${escapeNsis(nsisInstallDirectoryName)}"`,
 		"RequestExecutionLevel user",
+		"ShowInstDetails nevershow",
+		"AutoCloseWindow true",
+		...createNsisResourceDirectives(windowsResource, iconPath),
+		"Page instfiles",
 		"Section",
 		"  SetOutPath \"$INSTDIR\"",
 		`  File /r "${escapeNsis(target.outputPath)}\\*"`,
-		`  CreateShortCut "$SMPROGRAMS\\${escapeNsis(metadata.packageName)}.lnk" "$INSTDIR\\${escapeNsis((0, node_path.basename)(target.launcherPath))}"`,
+		`  CreateShortCut "$SMPROGRAMS\\${escapeNsis(nsisDisplayName)}.lnk" "$INSTDIR\\${escapeNsis(launcherFileName)}"`,
+		"  WriteUninstaller \"$INSTDIR\\Uninstall.exe\"",
+		`  WriteRegStr HKCU "${escapeNsis(uninstallRegistryKey)}" "DisplayName" "${escapeNsis(nsisDisplayName)}"`,
+		`  WriteRegStr HKCU "${escapeNsis(uninstallRegistryKey)}" "DisplayVersion" "${escapeNsis(metadata.version)}"`,
+		`  WriteRegStr HKCU "${escapeNsis(uninstallRegistryKey)}" "Publisher" "${escapeNsis(metadata.author)}"`,
+		`  WriteRegStr HKCU "${escapeNsis(uninstallRegistryKey)}" "InstallLocation" "$INSTDIR"`,
+		`  WriteRegStr HKCU "${escapeNsis(uninstallRegistryKey)}" "DisplayIcon" "$\\"$INSTDIR\\${escapeNsis(launcherFileName)}$\\""`,
+		`  WriteRegStr HKCU "${escapeNsis(uninstallRegistryKey)}" "UninstallString" "$\\"$INSTDIR\\Uninstall.exe$\\" /S"`,
+		`  WriteRegStr HKCU "${escapeNsis(uninstallRegistryKey)}" "QuietUninstallString" "$\\"$INSTDIR\\Uninstall.exe$\\" /S"`,
+		`  WriteRegDWORD HKCU "${escapeNsis(uninstallRegistryKey)}" "NoModify" 1`,
+		`  WriteRegDWORD HKCU "${escapeNsis(uninstallRegistryKey)}" "NoRepair" 1`,
+		"SectionEnd",
+		"",
+		"Section \"Uninstall\"",
+		`  Delete "$SMPROGRAMS\\${escapeNsis(nsisDisplayName)}.lnk"`,
+		`  DeleteRegKey HKCU "${escapeNsis(uninstallRegistryKey)}"`,
+		"  RMDir /r \"$INSTDIR\"",
+		`  RMDir /r "$LOCALAPPDATA\\${escapeNsis(target.runtimeAppId)}"`,
 		"SectionEnd",
+		"",
+		"Function .onInstSuccess",
+		"  IfSilent +3",
+		"  SetOutPath \"$INSTDIR\"",
+		`  Exec "$\\"$INSTDIR\\${escapeNsis(launcherFileName)}$\\""`,
+		"FunctionEnd",
 		""
 	].join("\n"));
 	await runTool("makensis", [scriptPath], root, environment);
@@ -519,8 +577,41 @@ var packageNsis = async (root, target, metadata, artifactsRoot, packageBuildRoot
 		path: outputPath
 	};
 };
+var createNsisResourceDirectives = (resource, iconPath) => {
+	const lines = [];
+	lines.push(`Icon "${escapeNsis(iconPath)}"`);
+	lines.push(`UninstallIcon "${escapeNsis(iconPath)}"`);
+	lines.push(`VIProductVersion "${escapeNsis(resource.fixedVersion)}"`);
+	lines.push(`VIFileVersion "${escapeNsis(resource.fixedVersion)}"`);
+	lines.push(`VIAddVersionKey /LANG=${resource.language} "CompanyName" "${escapeNsis(resource.companyName)}"`);
+	lines.push(`VIAddVersionKey /LANG=${resource.language} "FileDescription" "${escapeNsis(resource.fileDescription)}"`);
+	lines.push(`VIAddVersionKey /LANG=${resource.language} "FileVersion" "${escapeNsis(resource.version)}"`);
+	lines.push(`VIAddVersionKey /LANG=${resource.language} "ProductName" "${escapeNsis(resource.productName)}"`);
+	lines.push(`VIAddVersionKey /LANG=${resource.language} "ProductVersion" "${escapeNsis(resource.version)}"`);
+	if (resource.copyright !== void 0) lines.push(`VIAddVersionKey /LANG=${resource.language} "LegalCopyright" "${escapeNsis(resource.copyright)}"`);
+	return lines;
+};
+var reapplyPackWindowsResources = async (targets, resource, root, environment) => {
+	for (const target of targets) {
+		const descriptor = require_vite_internals.getMuonTargetDescriptor(target.target);
+		if (descriptor.os === "windows") {
+			await require_vite_internals.updateWindowsPeIconResource({
+				executablePath: (0, node_path.join)(target.outputPath, descriptor.runtimeExecutableName),
+				resource,
+				environment,
+				cwd: root
+			});
+			await require_vite_internals.updateWindowsPeResources({
+				executablePath: target.launcherPath,
+				resource,
+				environment,
+				cwd: root
+			});
+		}
+	}
+};
 /**
-* Builds a Vite app, creates Muon dist directories, and packages them.
+* Runs the Muon build sequence and creates redistributable packages.
 *
 * @param options Pack options.
 * @returns Generated package artifacts.
@@ -528,16 +619,50 @@ var packageNsis = async (root, target, metadata, artifactsRoot, packageBuildRoot
 var packMuonApp = async (options) => {
 	const cwd = (0, node_path.resolve)(options.root ?? process.cwd());
 	const environment = options.environment ?? process.env;
-	const loadedOptions = await loadViteMuonOptions(cwd);
-	const root = loadedOptions.root;
-	const metadata = resolveMetadata(await readPackageJson(root), options);
+	const project = await require_vite_internals.loadMuonBuildSequenceProject(cwd);
+	const root = project.root;
+	const packageJson = await readPackageJson(root);
+	const metadata = resolveMetadata(packageJson, options);
 	const artifactsRoot = (0, node_path.resolve)(root, options.artifactsDir ?? defaultArtifactsDirectory);
 	const packageBuildRoot = (0, node_path.resolve)(root, defaultPackageBuildDirectory);
 	const types = normalizePackTypes(options.types);
-	const viteOutputDirectory = await resolveBuildOutputDirectory(root);
-	await runViteBuild(root, environment);
-	const build = await require_vite_options.buildMuonApp(createBuildOptions(root, viteOutputDirectory, getPluginBuildOptions(loadedOptions.pluginOptions), options));
-	for (const type of types) for (const target of build.targets) assertPackTypeSupportsTarget(type, target.target);
+	const pluginBuildOptions = require_vite_internals.resolveMuonViteBuildOptions(project.pluginOptions);
+	const targetPlan = createPackTargetPlan(types, resolvePackTargetCandidates(options, pluginBuildOptions));
+	const buildOptions = {
+		root: cwd,
+		targets: targetPlan.map((entry) => entry.target),
+		allTargets: false
+	};
+	const windowsResourceOptions = require_vite_internals.mergeMuonWindowsResourceOptions(options.windowsResource, pluginBuildOptions.windowsResource);
+	const linuxDesktopOptions = require_vite_internals.mergeMuonLinuxDesktopOptions(options.linuxDesktop, pluginBuildOptions.linuxDesktop);
+	const iconPath = options.iconPath ?? pluginBuildOptions.iconPath;
+	if (options.configPath !== void 0) buildOptions.configPath = options.configPath;
+	if (iconPath !== void 0) buildOptions.iconPath = iconPath;
+	if (options.appName !== void 0) buildOptions.appName = options.appName;
+	if (options.appId !== void 0) buildOptions.appId = options.appId;
+	if (options.packageDirectory !== void 0) buildOptions.packageDirectory = options.packageDirectory;
+	if (windowsResourceOptions !== void 0) buildOptions.windowsResource = windowsResourceOptions;
+	if (linuxDesktopOptions !== void 0) buildOptions.linuxDesktop = linuxDesktopOptions;
+	const windowsResourceConfig = await require_vite_internals.readMuonConfigForWindowsResource(root, options.configPath);
+	const windowsResource = await require_vite_internals.resolveMuonWindowsResource({
+		root,
+		packageDirectory: options.packageDirectory ?? pluginBuildOptions.packageDirectory ?? "",
+		packageJson: createPackMetadataPackageJson(packageJson, metadata),
+		muonConfig: windowsResourceConfig.config,
+		muonConfigDirectory: windowsResourceConfig.directory,
+		options: windowsResourceOptions,
+		appIconPath: iconPath,
+		defaults: {
+			productName: metadata.packageName,
+			fileDescription: metadata.description,
+			companyName: metadata.author,
+			version: metadata.version,
+			copyright: void 0
+		}
+	});
+	const build = await require_vite_internals.runMuonBuildSequence(buildOptions, project);
+	if (options.packageVersion !== void 0) await reapplyPackWindowsResources(build.targets, windowsResource, root, environment);
+	const typesByTarget = new Map(targetPlan.map((entry) => [entry.target, entry.types]));
 	await (0, node_fs_promises.rm)(packageBuildRoot, {
 		recursive: true,
 		force: true
@@ -552,9 +677,10 @@ var packMuonApp = async (options) => {
 	});
 	await (0, node_fs_promises.mkdir)(artifactsRoot, { recursive: true });
 	const artifacts = [];
-	for (const target of build.targets) for (const type of types) if (type === "zip") artifacts.push(await packageZip(target, metadata, artifactsRoot));
+	for (const target of build.targets) for (const type of typesByTarget.get(target.target) ?? []) if (type === "zip") artifacts.push(await packageZip(target, metadata, artifactsRoot));
+	else if (type === "tar.gz") artifacts.push(await packageTarGz(target, metadata, artifactsRoot));
 	else if (type === "deb") artifacts.push(await packageDeb(root, target, metadata, artifactsRoot, packageBuildRoot, environment));
-	else artifacts.push(await packageNsis(root, target, metadata, artifactsRoot, packageBuildRoot, environment));
+	else artifacts.push(await packageNsis(root, target, metadata, windowsResource, artifactsRoot, packageBuildRoot, environment));
 	return {
 		root,
 		packageName: metadata.packageName,
@@ -568,8 +694,8 @@ var packMuonApp = async (options) => {
 };
 //#endregion
 //#region src/generated/packageMetadata.ts
-var version = "0.7.0";
-var git_commit_hash = "fe80718aaa617c0c0ea5c816bbe38d22bf2e8402";
+var version = "0.9.0";
+var git_commit_hash = "3437b522a51d8772713b72722b109c5ff30fc711";
 //#endregion
 //#region src/cli.ts
 var readTargetValues = (value) => {
@@ -579,7 +705,14 @@ var appendTargetValues = (value, previous) => {
 	return [...previous, ...readTargetValues(value)];
 };
 var appendPackTypeValues = (value, previous) => {
-	return [...previous, ...readTargetValues(value)];
+	return [...previous ?? [], ...readTargetValues(value)];
+};
+var readCommaSeparatedValues = (value) => value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+var readBooleanValue = (value, label) => {
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true" || normalized === "1" || normalized === "yes") return true;
+	if (normalized === "false" || normalized === "0" || normalized === "no") return false;
+	throw new Error(`${label} must be true or false.`);
 };
 var validateEmbedConfigOptions = (options) => {
 	if (options.runtimePath !== void 0 && options.corePath !== void 0) throw new Error("Specify at most one of --runtime-path or --core-path.");
@@ -588,20 +721,47 @@ var validateEmbedConfigOptions = (options) => {
 	if (options.runtimePath !== void 0 && options.output !== void 0) throw new Error("--output requires --core-path.");
 	if (options.bootstrapPath === void 0 && options.outputBootstrap !== void 0) throw new Error("--output-bootstrap requires --bootstrap-path.");
 };
+var createWindowsResourceOptions = (commandOptions) => {
+	const options = {};
+	if (commandOptions.windowsIcon !== void 0) options.iconPath = commandOptions.windowsIcon;
+	if (commandOptions.windowsProductName !== void 0) options.productName = commandOptions.windowsProductName;
+	if (commandOptions.windowsFileDescription !== void 0) options.fileDescription = commandOptions.windowsFileDescription;
+	if (commandOptions.windowsCompanyName !== void 0) options.companyName = commandOptions.windowsCompanyName;
+	if (commandOptions.windowsVersion !== void 0) options.version = commandOptions.windowsVersion;
+	if (commandOptions.windowsCopyright !== void 0) options.copyright = commandOptions.windowsCopyright;
+	return Object.keys(options).length === 0 ? void 0 : options;
+};
+var createLinuxDesktopOptions = (commandOptions) => {
+	const options = {};
+	if (commandOptions.linuxDesktopId !== void 0) options.desktopId = commandOptions.linuxDesktopId;
+	if (commandOptions.linuxName !== void 0) options.name = commandOptions.linuxName;
+	if (commandOptions.linuxComment !== void 0) options.comment = commandOptions.linuxComment;
+	if (commandOptions.linuxIcon !== void 0) options.iconPath = commandOptions.linuxIcon;
+	if (commandOptions.linuxCategories !== void 0) options.categories = readCommaSeparatedValues(commandOptions.linuxCategories);
+	if (commandOptions.linuxStartupNotify !== void 0) options.startupNotify = readBooleanValue(commandOptions.linuxStartupNotify, "--linux-startup-notify");
+	return Object.keys(options).length === 0 ? void 0 : options;
+};
 var runBuildCommand = async (commandOptions) => {
 	const targets = commandOptions.target;
 	if (commandOptions.all === true && targets.length > 0) throw new Error("Specify either --all or --target, not both.");
 	const buildOptions = {
 		root: process.cwd(),
-		allTargets: commandOptions.all === true
+		defaultAllTargets: false
 	};
 	if (targets.length > 0) buildOptions.targets = targets;
+	if (commandOptions.all === true) buildOptions.allTargets = true;
 	if (commandOptions.assets !== void 0) buildOptions.assetSourcePath = commandOptions.assets;
 	if (commandOptions.config !== void 0) buildOptions.configPath = commandOptions.config;
+	if (commandOptions.icon !== void 0) buildOptions.iconPath = commandOptions.icon;
+	const windowsResource = createWindowsResourceOptions(commandOptions);
+	if (windowsResource !== void 0) buildOptions.windowsResource = windowsResource;
+	const linuxDesktop = createLinuxDesktopOptions(commandOptions);
+	if (linuxDesktop !== void 0) buildOptions.linuxDesktop = linuxDesktop;
 	if (commandOptions.outDir !== void 0) buildOptions.outputRoot = commandOptions.outDir;
 	if (commandOptions.name !== void 0) buildOptions.appName = commandOptions.name;
 	if (commandOptions.appId !== void 0) buildOptions.appId = commandOptions.appId;
-	const result = await require_vite_options.buildMuonApp(buildOptions);
+	if (commandOptions.packageDirectory !== void 0) buildOptions.packageDirectory = commandOptions.packageDirectory;
+	const result = await require_vite_internals.runMuonBuildSequence(buildOptions);
 	if (commandOptions.json === true) console.log(JSON.stringify(result, null, 2));
 	else for (const target of result.targets) console.log(target.outputPath);
 };
@@ -610,12 +770,17 @@ var runPackCommand = async (commandOptions) => {
 	if (commandOptions.all === true && targets.length > 0) throw new Error("Specify either --all or --target, not both.");
 	const packOptions = {
 		root: process.cwd(),
-		types: commandOptions.type,
 		environment: process.env
 	};
+	if (commandOptions.type !== void 0) packOptions.types = commandOptions.type;
 	if (targets.length > 0) packOptions.targets = targets;
 	if (commandOptions.all !== void 0) packOptions.allTargets = commandOptions.all;
 	if (commandOptions.config !== void 0) packOptions.configPath = commandOptions.config;
+	if (commandOptions.icon !== void 0) packOptions.iconPath = commandOptions.icon;
+	const windowsResource = createWindowsResourceOptions(commandOptions);
+	if (windowsResource !== void 0) packOptions.windowsResource = windowsResource;
+	const linuxDesktop = createLinuxDesktopOptions(commandOptions);
+	if (linuxDesktop !== void 0) packOptions.linuxDesktop = linuxDesktop;
 	if (commandOptions.name !== void 0) packOptions.appName = commandOptions.name;
 	if (commandOptions.appId !== void 0) packOptions.appId = commandOptions.appId;
 	if (commandOptions.packageDirectory !== void 0) packOptions.packageDirectory = commandOptions.packageDirectory;
@@ -629,11 +794,11 @@ var runPackCommand = async (commandOptions) => {
 	else for (const artifact of result.artifacts) console.log(artifact.path);
 };
 var runPrepareCommand = async (commandOptions) => {
-	const result = await require_vite_options.runMuonPrepare({
+	const result = await require_vite_internals.runMuonPrepare({
 		muonPath: commandOptions.muonPath ?? "",
 		cefPath: commandOptions.cefPath,
 		stageDir: commandOptions.stageDir,
-		target: commandOptions.target ?? require_vite_options.getDefaultMuonPrepareTarget(process.platform, process.arch),
+		target: commandOptions.target ?? require_vite_internals.getDefaultMuonPrepareTarget(process.platform, process.arch),
 		cacheDir: commandOptions.cacheDir,
 		force: commandOptions.force === true,
 		quiet: commandOptions.quiet === true,
@@ -661,7 +826,7 @@ var runDevCommand = async (commandOptions, command) => {
 	if (result.exitCode !== 0) process.exitCode = result.exitCode;
 };
 var runInitCommand = async () => {
-	const result = await require_vite_options.ensureMuonGitignoreEntry(process.cwd());
+	const result = await require_vite_internals.ensureMuonGitignoreEntry(process.cwd());
 	console.log(result.changed ? `Updated ${result.gitignorePath}` : result.gitignorePath);
 };
 var printEmbedConfigResult = (result, json) => {
@@ -671,16 +836,16 @@ var printEmbedConfigResult = (result, json) => {
 var runEmbedConfigCommand = async (commandOptions) => {
 	validateEmbedConfigOptions(commandOptions);
 	const configPath = commandOptions.config ?? "";
-	const coreResult = commandOptions.corePath !== void 0 ? await require_vite_options.embedMuonConfigInCoreFile({
+	const coreResult = commandOptions.corePath !== void 0 ? await require_vite_internals.embedMuonConfigInCoreFile({
 		corePath: commandOptions.corePath,
 		configPath,
 		outputPath: commandOptions.output
-	}) : commandOptions.runtimePath !== void 0 ? await require_vite_options.embedMuonConfigInRuntime({
+	}) : commandOptions.runtimePath !== void 0 ? await require_vite_internals.embedMuonConfigInRuntime({
 		runtimePath: commandOptions.runtimePath,
 		configPath,
 		outputRuntimePath: commandOptions.outputRuntimePath
 	}) : void 0;
-	const bootstrapResult = commandOptions.bootstrapPath === void 0 ? void 0 : await require_vite_options.embedMuonConfigInBootstrapFile({
+	const bootstrapResult = commandOptions.bootstrapPath === void 0 ? void 0 : await require_vite_internals.embedMuonConfigInBootstrapFile({
 		bootstrapPath: commandOptions.bootstrapPath,
 		configPath,
 		outputPath: commandOptions.outputBootstrap
@@ -703,19 +868,19 @@ var createCliCommand = () => {
 		program.outputHelp({ error: true });
 		process.exitCode = 1;
 	});
-	program.command("build").description("Build CEF-free Muon app distribution directories").option("--target <target>", "public target or comma-separated public targets", appendTargetValues, []).option("--all", "build all supported targets").option("--assets <path>", "asset root path").option("--config <path>", "muon config path").option("--out-dir <path>", "output root directory").option("--name <name>", "launcher file name").option("--app-id <id>", "stable application identifier").option("--json", "write result as JSON").action(async (options) => {
+	program.command("build").description("Build CEF-free Muon app distribution directories").option("--target <target>", "public target or comma-separated public targets", appendTargetValues, []).option("--all", "build all supported targets").option("--assets <path>", "asset root path").option("--config <path>", "muon config path").option("--icon <path>", "static application PNG icon path").option("--windows-icon <path>", "Windows PNG icon resource path").option("--windows-product-name <name>", "Windows product name").option("--windows-file-description <text>", "Windows file description").option("--windows-company-name <name>", "Windows company name").option("--windows-version <version>", "Windows resource version").option("--windows-copyright <text>", "Windows legal copyright").option("--linux-desktop-id <id>", "Linux desktop entry identifier").option("--linux-name <name>", "Linux desktop display name").option("--linux-comment <text>", "Linux desktop comment").option("--linux-icon <path>", "Linux desktop PNG icon path").option("--linux-categories <list>", "Linux desktop categories").option("--linux-startup-notify <boolean>", "Linux startup notification").option("--out-dir <path>", "output root directory").option("--name <name>", "launcher file name").option("--app-id <id>", "stable application identifier").option("--package-directory <path>", "Muon package dist directory").option("--json", "write result as JSON").action(async (options) => {
 		await runBuildCommand(options);
 	});
-	program.command("pack").description("Build and package a Muon app").requiredOption("-t, --type <type>", "package type or comma-separated package types: zip, deb, nsis", appendPackTypeValues, []).option("--target <target>", "public target or comma-separated public targets", appendTargetValues, []).option("--all", "build all supported targets").option("--config <path>", "muon config path").option("--name <name>", "launcher file name").option("--app-id <id>", "stable application identifier").option("--package-directory <path>", "Muon package dist directory").option("--artifacts-dir <path>", "package artifact output directory").option("--package-name <name>", "package name override").option("--package-version <version>", "package version override").option("--description <text>", "package description override").option("--author <text>", "package author override").option("--json", "write result as JSON").action(async (options) => {
+	program.command("pack").description("Build and package a Muon app").option("--type <type>", "package type or comma-separated package types: zip, tar.gz, tgz, deb, nsis (default: all)", appendPackTypeValues).option("--target <target>", "public target, platform, arch, or comma-separated selectors", appendTargetValues, []).option("--all", "build all supported targets").option("--config <path>", "muon config path").option("--icon <path>", "static application PNG icon path").option("--windows-icon <path>", "Windows PNG icon resource path").option("--windows-product-name <name>", "Windows product name").option("--windows-file-description <text>", "Windows file description").option("--windows-company-name <name>", "Windows company name").option("--windows-version <version>", "Windows resource version").option("--windows-copyright <text>", "Windows legal copyright").option("--linux-desktop-id <id>", "Linux desktop entry identifier").option("--linux-name <name>", "Linux desktop display name").option("--linux-comment <text>", "Linux desktop comment").option("--linux-icon <path>", "Linux desktop PNG icon path").option("--linux-categories <list>", "Linux desktop categories").option("--linux-startup-notify <boolean>", "Linux startup notification").option("--name <name>", "launcher file name").option("--app-id <id>", "stable application identifier").option("--package-directory <path>", "Muon package dist directory").option("--artifacts-dir <path>", "package artifact output directory").option("--package-name <name>", "package name override").option("--package-version <version>", "package version override").option("--description <text>", "package description override").option("--author <text>", "package author override").option("--json", "write result as JSON").action(async (options) => {
 		await runPackCommand(options);
 	});
-	const devCommand = program.command("dev").description("Launch Muon directly with local development assets").option("--muon-path <path>", "Muon runtime file root").option("--cef-path <path>", "CEF file root").option("--stage-dir <path>", "prepared runtime output directory").option("--config <path>", "muon config path").option("--assets <path>", "development asset directory").option("--no-debugger", "disable Muon debugger defaults").option("--json", "write result as JSON").action(async (options) => {
+	const devCommand = program.command("run").description("Launch Muon directly with local development assets").option("--muon-path <path>", "Muon runtime file root").option("--cef-path <path>", "CEF file root").option("--stage-dir <path>", "prepared runtime output directory").option("--config <path>", "muon config path").option("--assets <path>", "development asset directory").option("--no-debugger", "disable Muon debugger defaults").option("--json", "write result as JSON").action(async (options) => {
 		await runDevCommand(options, devCommand);
 	});
 	program.command("init").description("Initialize Muon project helper files").action(async () => {
 		await runInitCommand();
 	});
-	program.command("prepare").description("Prepare a Muon runtime with CEF files").requiredOption("--muon-path <path>", "Muon runtime file root").option("--cef-path <path>", "CEF file root").option("--stage-dir <path>", "prepared runtime output directory").option("--target <target>", "prepare target").option("--cache-dir <path>", "CEF artifact cache directory").option("--force", "rebuild an existing prepared runtime").option("-q, --quiet", "suppress native prepare progress messages").option("--json", "write result as JSON").action(async (options) => {
+	program.command("prepare").description("Prepare a Muon runtime with CEF files").requiredOption("--muon-path <path>", "Muon runtime file root").option("--cef-path <path>", "CEF file root").option("--stage-dir <path>", "prepared runtime output directory").option("--target <target>", "prepare target").option("--cache-dir <path>", "CEF artifact cache directory").option("--force", "rebuild an existing prepared runtime").option("-q, --quiet", "suppress native builder progress messages").option("--json", "write result as JSON").action(async (options) => {
 		await runPrepareCommand(options);
 	});
 	program.command("embed-config").description("Embed muon.json into Muon runtime files").option("--runtime-path <path>", "prepared runtime directory").option("--core-path <path>", "muon-core executable path").option("--bootstrap-path <path>", "muon-bootstrap executable path").requiredOption("--config <path>", "muon config path").option("--output-runtime-path <path>", "patched runtime output directory").option("--output <path>", "patched muon-core output path").option("--output-bootstrap <path>", "patched bootstrap output path").option("--json", "write result as JSON").action(async (options) => {