muon-ui 0.6.0 → 0.8.0

package/dist/cli.cjs

@@ -1,21 +1,24 @@
 #!/usr/bin/env node
 /*!
 * name: muon-ui
-* version: 0.6.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: 44340328835f0d4ee860b444916971dfa03486ef
+* git.commit.hash: 9bb6148e155dab16c4ca441073b144e21981b038
 */
-const require_vite_options = require("./vite-options-KNDVcH-e.cjs");
+const require_vite_internals = require("./vite-internals-ChWiL2TL.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_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",
@@ -23,7 +26,7 @@ var defaultProjectConfigFileNames = [
 	"muon.json"
 ];
 var resolveFromRoot = (root, path) => (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(root, path);
-var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isJsonObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 var fileExists = async (path) => {
 	try {
@@ -66,7 +69,7 @@ var loadViteMuonOptions = 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,
@@ -84,7 +87,7 @@ var resolveProjectConfigPath = async (root, configPath) => {
 		if (await fileExists(candidatePath)) return candidatePath;
 	}
 };
-var readJsonObjectFile = async (filePath, label) => {
+var readJsonObjectFile$1 = async (filePath, label) => {
 	let content;
 	try {
 		content = await (0, node_fs_promises.readFile)(filePath, "utf8");
@@ -97,7 +100,7 @@ var readJsonObjectFile = async (filePath, label) => {
 	} catch (error) {
 		throw new Error(`${label} could not be parsed: ${filePath}: ${getErrorMessage(error)}`);
 	}
-	if (!isJsonObject(parsed)) throw new Error(`${label} must contain a JSON object: ${filePath}`);
+	if (!isJsonObject$1(parsed)) throw new Error(`${label} must contain a JSON object: ${filePath}`);
 	return parsed;
 };
 var resolveProjectConfig = async (root, configPath) => {
@@ -108,14 +111,14 @@ var resolveProjectConfig = async (root, configPath) => {
 	};
 	return {
 		configPath: resolvedConfigPath,
-		config: await readJsonObjectFile(resolvedConfigPath, "muon config")
+		config: await readJsonObjectFile$1(resolvedConfigPath, "muon config")
 	};
 };
 var readConfigAssetSourcePath = (config) => {
 	if (config === void 0) return;
 	const asset = config.asset;
 	if (asset === void 0) return;
-	if (!isJsonObject(asset)) throw new Error("muon config asset must be an object when present.");
+	if (!isJsonObject$1(asset)) throw new Error("muon config asset must be an object when present.");
 	const sourcePath = asset.sourcePath;
 	if (sourcePath === void 0) return;
 	if (typeof sourcePath !== "string") throw new Error("muon config asset.sourcePath must be a string.");
@@ -201,8 +204,8 @@ var runMuonDev = async (options = {}) => {
 	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
@@ -213,8 +216,8 @@ var runMuonDev = async (options = {}) => {
 	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({
+	await require_vite_internals.ensureMuonGitignoreEntry(root);
+	const preparedRuntime = await require_vite_internals.runMuonPrepare({
 		muonPath,
 		cefPath,
 		stageDir: stagePath,
@@ -226,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,
@@ -244,9 +247,441 @@ var runMuonDev = async (options = {}) => {
 	};
 };
 //#endregion
+//#region src/pack.ts
+var AdmZip = __resolveDefaultExport(adm_zip.default, false);
+globalThis.__screwUpIsInCJS_733954c41a89 = true;
+function __resolveDefaultExport(module, isESM) {
+	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_733954c41a89 === 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 supportedPackTypes = [
+	"zip",
+	"tar.gz",
+	"deb",
+	"nsis"
+];
+var defaultArtifactsDirectory = "artifacts";
+var defaultPackageBuildDirectory = ".muon/pack";
+var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+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}`);
+	return parsed;
+};
+var readPackageJson = async (root) => {
+	return await readJsonObjectFile((0, node_path.join)(root, "package.json"));
+};
+var sanitizePackageName = (value) => {
+	const sanitized = (value.startsWith("@") ? value.slice(value.indexOf("/") + 1) : value).trim().toLowerCase().replace(/[^a-z0-9+.-]+/g, "-").replace(/^[.+-]+/g, "").replace(/[.+-]+$/g, "");
+	return sanitized.length > 0 ? sanitized : "muon-app";
+};
+var stringifyAuthor = (value) => {
+	if (typeof value === "string") return value;
+	if (!isJsonObject(value) || typeof value.name !== "string") return;
+	return value.email === void 0 || typeof value.email !== "string" ? value.name : `${value.name} <${value.email}>`;
+};
+var resolveMetadata = (packageJson, options) => {
+	const packageNameSource = options.packageName ?? (typeof packageJson.name === "string" ? packageJson.name : void 0);
+	if (packageNameSource === void 0 || packageNameSource.trim() === "") throw new Error("package.json name is required for muon pack.");
+	const version = options.packageVersion ?? (typeof packageJson.version === "string" ? packageJson.version : void 0);
+	if (version === void 0 || version.trim() === "") throw new Error("package.json version is required for muon pack.");
+	const description = options.description ?? (typeof packageJson.description === "string" ? packageJson.description : "Muon application");
+	const author = options.author ?? stringifyAuthor(packageJson.author) ?? "Unknown";
+	return {
+		packageName: sanitizePackageName(packageNameSource),
+		version,
+		description,
+		author
+	};
+};
+var createPackMetadataPackageJson = (packageJson, metadata) => ({
+	...packageJson,
+	version: metadata.version
+});
+var normalizePackTypes = (types) => {
+	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 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], {
+		cwd,
+		env: environment,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	let stderr = "";
+	child.stderr.setEncoding("utf8");
+	child.stderr.on("data", (chunk) => {
+		stderr += chunk;
+	});
+	const exitCode = await new Promise((resolvePromise, reject) => {
+		child.once("error", reject);
+		child.once("close", (code) => {
+			resolvePromise(code ?? 1);
+		});
+	});
+	if (exitCode !== 0) throw new Error(`${executable} failed with exit code ${exitCode}: ${stderr.trim()}`);
+};
+var statOrUndefined = async (path) => {
+	try {
+		return await (0, node_fs_promises.stat)(path);
+	} catch {
+		return;
+	}
+};
+var addDirectoryToZip = async (zip, directory, entryRoot) => {
+	const walk = async (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);
+			if (entry.isDirectory()) await walk(path);
+			else if (entry.isFile()) {
+				const stats = await (0, node_fs_promises.stat)(path);
+				const relativePath = (0, node_path.relative)(directory, path).split(node_path.sep).join("/");
+				zip.addFile(`${entryRoot}/${relativePath}`, await (0, node_fs_promises.readFile)(path), void 0, stats.mode << 16);
+			}
+		}
+	};
+	await walk(directory);
+};
+var packageZip = async (target, metadata, artifactsRoot) => {
+	const zip = new AdmZip();
+	await addDirectoryToZip(zip, target.outputPath, target.distributionDirectoryName);
+	const outputPath = (0, node_path.join)(artifactsRoot, `${metadata.packageName}-${metadata.version}-${target.target}.zip`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(outputPath, zip.toBuffer());
+	return {
+		type: "zip",
+		target: target.target,
+		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_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}`);
+	await (0, node_fs_promises.rm)(packageRoot, {
+		recursive: true,
+		force: true
+	});
+	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 });
+	await (0, node_fs_promises.writeFile)(binPath, [
+		"#!/usr/bin/env bash",
+		"set -euo pipefail",
+		`exec ${JSON.stringify(`/usr/lib/${metadata.packageName}/${target.distributionDirectoryName}/${launcherName}`)} "$@"`,
+		""
+	].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, [
+		`Package: ${metadata.packageName}`,
+		`Version: ${metadata.version}`,
+		`Architecture: ${architecture}`,
+		`Maintainer: ${metadata.author}`,
+		`Description: ${metadata.description}`,
+		""
+	].join("\n"));
+	const outputPath = (0, node_path.join)(artifactsRoot, `${metadata.packageName}-${metadata.version}-${architecture}.deb`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	await runTool("dpkg-deb", [
+		"--build",
+		packageRoot,
+		outputPath
+	], root, environment);
+	return {
+		type: "deb",
+		target: target.target,
+		path: outputPath
+	};
+};
+var escapeNsis = (value) => value.replaceAll("\\", "\\\\").replaceAll("\"", "$\\\"");
+var nsisUninstallRegistryRoot = "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall";
+var createNsisUninstallRegistryKey = (appId) => `${nsisUninstallRegistryRoot}\\${appId}`;
+var packageNsis = async (root, target, metadata, appId, 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 uninstallRegistryKey = createNsisUninstallRegistryKey(appId);
+	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 = windowsResource.iconPath === void 0 ? void 0 : (0, node_path.join)((0, node_path.dirname)(scriptPath), `${metadata.packageName}-${target.target}.ico`);
+	if (windowsResource.iconPath !== void 0 && iconPath !== void 0) await require_vite_internals.createWindowsIconFromPngFile(windowsResource.iconPath, iconPath);
+	await (0, node_fs_promises.writeFile)(scriptPath, [
+		"Unicode true",
+		`Name "${escapeNsis(metadata.packageName)}"`,
+		`OutFile "${escapeNsis(outputPath)}"`,
+		`InstallDir "$LOCALAPPDATA\\Programs\\${escapeNsis(metadata.packageName)}"`,
+		"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(launcherFileName)}"`,
+		"  WriteUninstaller \"$INSTDIR\\Uninstall.exe\"",
+		`  WriteRegStr HKCU "${escapeNsis(uninstallRegistryKey)}" "DisplayName" "${escapeNsis(metadata.packageName)}"`,
+		`  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(metadata.packageName)}.lnk"`,
+		`  DeleteRegKey HKCU "${escapeNsis(uninstallRegistryKey)}"`,
+		"  RMDir /r \"$INSTDIR\"",
+		`  RMDir /r "$LOCALAPPDATA\\${escapeNsis(appId)}"`,
+		"SectionEnd",
+		"",
+		"Function .onInstSuccess",
+		"  IfSilent +3",
+		"  SetOutPath \"$INSTDIR\"",
+		`  Exec "$\\"$INSTDIR\\${escapeNsis(launcherFileName)}$\\""`,
+		"FunctionEnd",
+		""
+	].join("\n"));
+	await runTool("makensis", [scriptPath], root, environment);
+	if (await statOrUndefined(outputPath) === void 0) throw new Error(`makensis did not create installer: ${outputPath}`);
+	return {
+		type: "nsis",
+		target: target.target,
+		path: outputPath
+	};
+};
+var createNsisResourceDirectives = (resource, iconPath) => {
+	const lines = [];
+	if (iconPath !== void 0) {
+		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) if (require_vite_internals.getMuonTargetDescriptor(target.target).os === "windows") await require_vite_internals.updateWindowsPeResources({
+		executablePath: target.launcherPath,
+		resource,
+		environment,
+		cwd: root
+	});
+};
+/**
+* Runs the Muon build sequence and creates redistributable packages.
+*
+* @param options Pack options.
+* @returns Generated package artifacts.
+*/
+var packMuonApp = async (options) => {
+	const cwd = (0, node_path.resolve)(options.root ?? process.cwd());
+	const environment = options.environment ?? process.env;
+	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 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);
+	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;
+	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,
+		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
+	});
+	await (0, node_fs_promises.rm)((0, node_path.join)(artifactsRoot, "deb"), {
+		recursive: true,
+		force: true
+	});
+	await (0, node_fs_promises.rm)((0, node_path.join)(artifactsRoot, "nsis"), {
+		recursive: true,
+		force: true
+	});
+	await (0, node_fs_promises.mkdir)(artifactsRoot, { recursive: true });
+	const artifacts = [];
+	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, build.appId, windowsResource, artifactsRoot, packageBuildRoot, environment));
+	return {
+		root,
+		packageName: metadata.packageName,
+		version: metadata.version,
+		appName: build.appName,
+		appId: build.appId,
+		build,
+		targets: build.targets,
+		artifacts
+	};
+};
+//#endregion
 //#region src/generated/packageMetadata.ts
-var version = "0.6.0";
-var git_commit_hash = "44340328835f0d4ee860b444916971dfa03486ef";
+var version = "0.8.0";
+var git_commit_hash = "9bb6148e155dab16c4ca441073b144e21981b038";
 //#endregion
 //#region src/cli.ts
 var readTargetValues = (value) => {
@@ -255,6 +690,16 @@ var readTargetValues = (value) => {
 var appendTargetValues = (value, previous) => {
 	return [...previous, ...readTargetValues(value)];
 };
+var appendPackTypeValues = (value, previous) => {
+	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.");
 	if (options.runtimePath === void 0 && options.corePath === void 0 && options.bootstrapPath === void 0) throw new Error("Specify at least one of --runtime-path, --core-path, or --bootstrap-path.");
@@ -262,28 +707,82 @@ 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;
+	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;
-	const result = await require_vite_options.buildMuonApp(buildOptions);
+	if (commandOptions.appId !== void 0) buildOptions.appId = commandOptions.appId;
+	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);
 };
+var runPackCommand = async (commandOptions) => {
+	const targets = commandOptions.target;
+	if (commandOptions.all === true && targets.length > 0) throw new Error("Specify either --all or --target, not both.");
+	const packOptions = {
+		root: process.cwd(),
+		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;
+	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;
+	if (commandOptions.artifactsDir !== void 0) packOptions.artifactsDir = commandOptions.artifactsDir;
+	if (commandOptions.packageName !== void 0) packOptions.packageName = commandOptions.packageName;
+	if (commandOptions.packageVersion !== void 0) packOptions.packageVersion = commandOptions.packageVersion;
+	if (commandOptions.description !== void 0) packOptions.description = commandOptions.description;
+	if (commandOptions.author !== void 0) packOptions.author = commandOptions.author;
+	const result = await packMuonApp(packOptions);
+	if (commandOptions.json === true) console.log(JSON.stringify(result, null, 2));
+	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,
@@ -311,7 +810,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) => {
@@ -321,16 +820,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
@@ -353,16 +852,19 @@ var createCliCommand = () => {
 		program.outputHelp({ error: true });
 		process.exitCode = 1;
 	});
-	program.command("build").description("Build CEF-free Muon app distribution directories").option("--target <target>", "target alias or comma-separated target aliases", 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("--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("--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").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("--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) => {
 		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) => {