muon-ui 0.11.0 → 0.13.0

package/dist/cli.cjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 /*!
 * name: muon-ui
-* version: 0.11.0
+* version: 0.13.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: db70f7643ac9fb1f61ab79f1de55c3dd8686de8d
+* git.commit.hash: 8eedbe10e5a89eef8f7061d528518353bd09083e
 */
-const require_vite_internals = require("./vite-internals-Dha0jYI8.cjs");
+const require_vite_internals = require("./vite-internals-6HS7FULY.cjs");
 let commander = require("commander");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
@@ -76,6 +76,62 @@ var loadViteMuonOptions = async (cwd) => {
 		pluginOptions: muonPlugins[0]
 	};
 };
+var getRuntimePluginConfigFromViteBuild = async (root) => {
+	const vite = await import("vite");
+	let resolvedRuntimeStates = [];
+	const inspector = {
+		name: "muon-run-vite-build-inspector",
+		enforce: "post",
+		configResolved: (config) => {
+			const runtimeStates = config.plugins.map((plugin) => require_vite_internals.getMuonVitePluginRuntimeState(plugin)).filter((runtimeState) => runtimeState !== void 0);
+			if (runtimeStates.length > 1) throw new Error("Multiple muon() plugin definitions were found in vite.config.*.");
+			resolvedRuntimeStates = runtimeStates;
+		}
+	};
+	const previous = process.env[require_vite_internals.muonBuildSequenceSuppressViteBuildEnvironmentKey];
+	process.env[require_vite_internals.muonBuildSequenceSuppressViteBuildEnvironmentKey] = "1";
+	try {
+		await vite.build({
+			root,
+			logLevel: "silent",
+			plugins: [inspector]
+		});
+	} finally {
+		if (previous === void 0) delete process.env[require_vite_internals.muonBuildSequenceSuppressViteBuildEnvironmentKey];
+		else process.env[require_vite_internals.muonBuildSequenceSuppressViteBuildEnvironmentKey] = previous;
+	}
+	const runtimePluginConfig = resolvedRuntimeStates[0]?.getRuntimePluginConfig();
+	if (runtimePluginConfig === void 0) throw new Error("muon Vite plugin runtime config was not resolved.");
+	return runtimePluginConfig;
+};
+var copyViteOutputAsRunAssets = async (project, assetSourcePath, assetPrefix) => {
+	if (project.viteOutputDirectory === void 0) throw new Error("Vite output directory could not be resolved.");
+	await assertDevelopmentAssetDirectory(project.viteOutputDirectory);
+	const destinationPath = (0, node_path.join)(assetSourcePath, ...assetPrefix.split("/"));
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(destinationPath), { recursive: true });
+	await (0, node_fs_promises.cp)(project.viteOutputDirectory, destinationPath, { recursive: true });
+};
+var prepareViteRunAssets = async (cwd) => {
+	const project = await require_vite_internals.loadMuonBuildSequenceProject(cwd);
+	if (project.pluginOptions === void 0) return;
+	const buildOptions = require_vite_internals.resolveMuonViteBuildOptions(project.pluginOptions);
+	const packagedAssetOptions = require_vite_internals.createVitePackagedAssetOptions(project.viteBase ?? "/");
+	const assetSourcePath = (0, node_path.join)(project.root, ".muon", "run", "assets");
+	await (0, node_fs_promises.rm)(assetSourcePath, {
+		recursive: true,
+		force: true
+	});
+	const runtimePluginConfig = await getRuntimePluginConfigFromViteBuild(project.viteBuildRoot);
+	await copyViteOutputAsRunAssets(project, assetSourcePath, packagedAssetOptions.assetPrefix);
+	return {
+		root: project.root,
+		pluginOptions: project.pluginOptions,
+		configPath: buildOptions.configPath,
+		assetSourcePath,
+		browserStartPage: packagedAssetOptions.browserStartPage,
+		runtimePluginConfig
+	};
+};
 var resolveProjectConfigPath = async (root, configPath) => {
 	if (configPath !== void 0) {
 		const resolvedPath = resolveFromRoot(root, configPath);
@@ -125,6 +181,11 @@ var readConfigAssetSourcePath = (config) => {
 	if (sourcePath.trim().length === 0) throw new Error("muon config asset.sourcePath must not be empty.");
 	return sourcePath;
 };
+var hasConfigBrowserStartPage = (config) => {
+	if (config === void 0) return false;
+	const browser = config.browser;
+	return isJsonObject$1(browser) && browser.startPage !== void 0;
+};
 var assertDevelopmentAssetDirectory = async (assetSourcePath) => {
 	if (await directoryExists(assetSourcePath)) return;
 	try {
@@ -155,50 +216,48 @@ var resolveAssetSource = async (root, assetSourcePath, projectConfig) => {
 		overrideAssetSourcePath: defaultAssetSourcePath
 	};
 };
-var createMuonDevOverrideConfig = (assetSourcePath, enableDebugger) => ({
-	...assetSourcePath === void 0 ? {} : { asset: { sourcePath: assetSourcePath } },
-	...enableDebugger ? {
-		cdp: { enable: true },
-		browser: { keybind: {
+var createMuonDevOverrideConfig = (assetSourcePath, enableDebugger, browserStartPage, runtimePluginConfig) => {
+	const browser = browserStartPage === void 0 && !enableDebugger ? void 0 : {
+		...browserStartPage === void 0 ? {} : { startPage: browserStartPage },
+		...enableDebugger ? { keybind: {
 			devtools: "f12",
 			recycle: "ctrl+f12"
-		} }
-	} : {}
-});
+		} } : {}
+	};
+	return {
+		...assetSourcePath === void 0 ? {} : { asset: { sourcePath: assetSourcePath } },
+		...enableDebugger ? { cdp: { enable: true } } : {},
+		...browser === void 0 ? {} : { browser },
+		...runtimePluginConfig === void 0 ? {} : { plugin: runtimePluginConfig }
+	};
+};
 var writeMuonDevOverrideConfig = async (overrideConfigPath, overrideConfig) => {
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(overrideConfigPath), { recursive: true });
 	await (0, node_fs_promises.writeFile)(overrideConfigPath, `${JSON.stringify(overrideConfig, null, 2)}\n`);
 };
 var runMuonExecutable = async (muonExecutablePath, configPaths, environment) => {
-	const args = configPaths.flatMap((configPath) => ["-c", configPath]);
-	let exitCode = 0;
-	do {
-		const child = (0, node_child_process.spawn)(muonExecutablePath, args, {
-			cwd: (0, node_path.dirname)(muonExecutablePath),
-			env: environment,
-			stdio: [
-				"ignore",
-				"inherit",
-				"inherit"
-			]
-		});
-		exitCode = await new Promise((resolvePromise, reject) => {
-			child.once("error", reject);
-			child.once("close", (code) => {
-				resolvePromise(code ?? 1);
-			});
+	const child = (0, node_child_process.spawn)(muonExecutablePath, configPaths.flatMap((configPath) => ["-c", configPath]), {
+		cwd: (0, node_path.dirname)(muonExecutablePath),
+		env: environment,
+		stdio: [
+			"ignore",
+			"inherit",
+			"inherit"
+		]
+	});
+	return await new Promise((resolvePromise, reject) => {
+		child.once("error", reject);
+		child.once("close", (code) => {
+			resolvePromise(code ?? 1);
 		});
-	} while (exitCode === muonRecycleExitCode);
-	return exitCode;
+	});
 };
-/**
-* Launches muon directly against local development assets.
-*
-* @param options Development startup options.
-* @returns Development startup result after the muon process exits.
-*/
-var runMuonDev = async (options = {}) => {
-	const loadedViteOptions = await loadViteMuonOptions((0, node_path.resolve)(options.root ?? process.cwd()));
+var runMuonDevOnce = async (options, cwd) => {
+	const preparedViteAssets = options.assetSourcePath === void 0 ? await prepareViteRunAssets(cwd) : void 0;
+	const loadedViteOptions = preparedViteAssets === void 0 ? await loadViteMuonOptions(cwd) : {
+		root: preparedViteAssets.root,
+		pluginOptions: preparedViteAssets.pluginOptions
+	};
 	const root = loadedViteOptions.root;
 	const pluginOptions = loadedViteOptions.pluginOptions;
 	const platform = options.platform ?? process.platform;
@@ -213,8 +272,12 @@ var runMuonDev = async (options = {}) => {
 	const cefPath = options.cefPath !== void 0 ? resolveFromRoot(root, options.cefPath) : pluginOptions?.cefPath === void 0 ? void 0 : resolveFromRoot(root, pluginOptions.cefPath);
 	const stagePath = options.stagePath !== void 0 ? resolveFromRoot(root, options.stagePath) : pluginOptions?.stagePath === void 0 ? (0, node_path.resolve)(root, ".muon", target) : resolveFromRoot(root, pluginOptions.stagePath);
 	const enableDebugger = options.enableDebugger ?? pluginOptions?.enableDebugger ?? true;
-	const projectConfig = await resolveProjectConfig(root, options.configPath);
-	const asset = await resolveAssetSource(root, options.assetSourcePath, projectConfig);
+	const projectConfig = await resolveProjectConfig(root, options.configPath ?? preparedViteAssets?.configPath);
+	const asset = preparedViteAssets === void 0 ? await resolveAssetSource(root, options.assetSourcePath, projectConfig) : {
+		assetSourcePath: preparedViteAssets.assetSourcePath,
+		overrideAssetSourcePath: preparedViteAssets.assetSourcePath
+	};
+	const browserStartPage = preparedViteAssets?.browserStartPage !== void 0 && !hasConfigBrowserStartPage(projectConfig.config) ? preparedViteAssets.browserStartPage : void 0;
 	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({
@@ -230,7 +293,7 @@ var runMuonDev = async (options = {}) => {
 		cwd: root
 	});
 	if (preparedRuntime.stagePath === void 0) throw new Error("muon-builder did not return a staged runtime path.");
-	await writeMuonDevOverrideConfig(overrideConfigPath, createMuonDevOverrideConfig(asset.overrideAssetSourcePath, enableDebugger));
+	await writeMuonDevOverrideConfig(overrideConfigPath, createMuonDevOverrideConfig(asset.overrideAssetSourcePath, enableDebugger, browserStartPage, preparedViteAssets?.runtimePluginConfig));
 	const muonExecutablePath = require_vite_internals.getMuonExecutablePath(preparedRuntime.stagePath, platform);
 	const exitCode = await runMuonExecutable(muonExecutablePath, [...projectConfig.configPath === void 0 ? [] : [projectConfig.configPath], overrideConfigPath], environment);
 	return {
@@ -246,6 +309,20 @@ var runMuonDev = async (options = {}) => {
 		exitCode
 	};
 };
+/**
+* Launches muon directly against local development assets.
+*
+* @param options Development startup options.
+* @returns Development startup result after the muon process exits.
+*/
+var runMuonDev = async (options = {}) => {
+	const cwd = (0, node_path.resolve)(options.root ?? process.cwd());
+	let result;
+	do
+		result = await runMuonDevOnce(options, cwd);
+	while (result.exitCode === muonRecycleExitCode);
+	return result;
+};
 //#endregion
 //#region src/pack.ts
 var AdmZip = __resolveDefaultExport(adm_zip.default, false);
@@ -280,7 +357,41 @@ var defaultPackageBuildDirectory = ".muon/pack";
 var systemRuntimeRoot = "/var/lib/muon/apps";
 var systemCefCacheRoot = "/var/cache/muon/cef";
 var runtimeHelperExecutableName = "muon-runtime-helper";
-var debGtk3RuntimeDependency = "libgtk-3-0t64 | libgtk-3-0";
+var portableProfilePath = "profile";
+var portableInstallMetadata = {
+	type: "portable",
+	runtimeMode: "in-place"
+};
+var debRuntimeDependencies = [
+	"libc6",
+	"libgcc-s1",
+	"libstdc++6",
+	"libffi8",
+	"libexpat1",
+	"libdbus-1-3",
+	"libglib2.0-0t64 | libglib2.0-0",
+	"libgtk-3-0t64 | libgtk-3-0",
+	"libatk-bridge2.0-0t64 | libatk-bridge2.0-0",
+	"libatk1.0-0t64 | libatk1.0-0",
+	"libatspi2.0-0t64 | libatspi2.0-0",
+	"libcups2t64 | libcups2",
+	"libnspr4",
+	"libnss3",
+	"libgbm1",
+	"libasound2t64 | libasound2",
+	"libudev1",
+	"libx11-6",
+	"libxcb1",
+	"libxcomposite1",
+	"libxdamage1",
+	"libxext6",
+	"libxfixes3",
+	"libxi6",
+	"libxkbcommon0",
+	"libxrandr2",
+	"libcairo2",
+	"libpango-1.0-0"
+];
 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"));
@@ -369,6 +480,7 @@ 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 isPortablePackType = (type) => type === "zip" || type === "tar.gz";
 var createPackTargetPlan = (types, targets) => {
 	const plan = targets.map((target) => ({
 		target,
@@ -404,6 +516,17 @@ var runTool = async (executable, args, cwd, environment) => {
 	});
 	if (exitCode !== 0) throw new Error(`${executable} failed with exit code ${exitCode}: ${stderr.trim()}`);
 };
+var isUnavailableToolError = (error, executable) => {
+	if (!(error instanceof Error)) return false;
+	const nodeError = error;
+	return nodeError.code === "ENOENT" && (nodeError.syscall === `spawn ${executable}` || nodeError.path === executable);
+};
+var reportSkippedUnavailableTool = (progress, executable, type, target) => {
+	progress?.({
+		phase: "pack",
+		status: `Warning: ${executable} is not available; skipping ${type} package for ${target}.`
+	});
+};
 var statOrUndefined = async (path) => {
 	try {
 		return await (0, node_fs_promises.stat)(path);
@@ -427,9 +550,10 @@ var addDirectoryToZip = async (zip, directory, entryRoot) => {
 	};
 	await walk(directory);
 };
+var getPortableArchiveEntryRoot = (target, metadata) => `${metadata.packageName}/${target.target}`;
 var packageZip = async (target, metadata, artifactsRoot) => {
 	const zip = new AdmZip();
-	await addDirectoryToZip(zip, target.outputPath, target.distributionDirectoryName);
+	await addDirectoryToZip(zip, target.outputPath, getPortableArchiveEntryRoot(target, metadata));
 	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());
@@ -459,13 +583,16 @@ var createTarGzEntryGenerator = async function* (directory, entryRoot) {
 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);
+	await (0, tar_vern.storeReaderToFile)((0, tar_vern.createTarPacker)(createTarGzEntryGenerator(target.outputPath, getPortableArchiveEntryRoot(target, metadata)), "gzip"), outputPath);
 	return {
 		type: "tar.gz",
 		target: target.target,
 		path: outputPath
 	};
 };
+var writePortableInstallMetadata = async (target) => {
+	await (0, node_fs_promises.writeFile)((0, node_path.join)(target.outputPath, "muon-install.json"), `${JSON.stringify(portableInstallMetadata, void 0, 2)}\n`);
+};
 var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot, environment, linuxSandbox, progress) => {
 	const descriptor = require_vite_internals.getMuonTargetDescriptor(target.target);
 	if (descriptor.os !== "linux") throw new Error(`Unsupported deb target: ${target.target}`);
@@ -523,7 +650,7 @@ var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot,
 		`Version: ${metadata.version}`,
 		`Architecture: ${architecture}`,
 		`Maintainer: ${metadata.author}`,
-		`Depends: ${debGtk3RuntimeDependency}`,
+		`Depends: ${debRuntimeDependencies.join(", ")}`,
 		`Description: ${metadata.description}`,
 		""
 	].join("\n"));
@@ -562,12 +689,20 @@ var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot,
 		phase: "pack",
 		status: "Running dpkg-deb"
 	});
-	await runTool("dpkg-deb", [
-		"--root-owner-group",
-		"--build",
-		packageRoot,
-		outputPath
-	], root, environment);
+	try {
+		await runTool("dpkg-deb", [
+			"--root-owner-group",
+			"--build",
+			packageRoot,
+			outputPath
+		], root, environment);
+	} catch (error) {
+		if (isUnavailableToolError(error, "dpkg-deb")) {
+			reportSkippedUnavailableTool(progress, "dpkg-deb", "deb", target.target);
+			return;
+		}
+		throw error;
+	}
 	return {
 		type: "deb",
 		target: target.target,
@@ -577,7 +712,7 @@ var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot,
 var escapeNsis = (value) => value.replaceAll("\\", "\\\\").replaceAll("\"", "$\\\"");
 var nsisUninstallRegistryRoot = "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall";
 var createNsisUninstallRegistryKey = (appId) => `${nsisUninstallRegistryRoot}\\${appId}`;
-var packageNsis = async (root, target, metadata, windowsResource, artifactsRoot, packageBuildRoot, environment, progress) => {
+var packageNsis = async (root, target, metadata, windowsResource, windowsCodeSigning, artifactsRoot, packageBuildRoot, environment, progress) => {
 	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`);
@@ -590,10 +725,17 @@ var packageNsis = async (root, target, metadata, windowsResource, artifactsRoot,
 	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);
+	const codeSigningDirectives = await createNsisCodeSigningDirectives({
+		root,
+		scriptPath,
+		target: target.target,
+		codeSigning: windowsCodeSigning
+	});
 	await (0, node_fs_promises.writeFile)(scriptPath, [
 		"Unicode true",
 		`Name "${escapeNsis(nsisDisplayName)}"`,
 		`OutFile "${escapeNsis(outputPath)}"`,
+		...codeSigningDirectives,
 		`InstallDir "$LOCALAPPDATA\\Programs\\${escapeNsis(nsisInstallDirectoryName)}"`,
 		"RequestExecutionLevel user",
 		"ShowInstDetails nevershow",
@@ -634,7 +776,15 @@ var packageNsis = async (root, target, metadata, windowsResource, artifactsRoot,
 		phase: "pack",
 		status: "Running makensis"
 	});
-	await runTool("makensis", [scriptPath], root, environment);
+	try {
+		await runTool("makensis", [scriptPath], root, environment);
+	} catch (error) {
+		if (isUnavailableToolError(error, "makensis")) {
+			reportSkippedUnavailableTool(progress, "makensis", "nsis", target.target);
+			return;
+		}
+		throw error;
+	}
 	if (await statOrUndefined(outputPath) === void 0) throw new Error(`makensis did not create installer: ${outputPath}`);
 	return {
 		type: "nsis",
@@ -656,6 +806,51 @@ var createNsisResourceDirectives = (resource, iconPath) => {
 	if (resource.copyright !== void 0) lines.push(`VIAddVersionKey /LANG=${resource.language} "LegalCopyright" "${escapeNsis(resource.copyright)}"`);
 	return lines;
 };
+var createNsisCodeSigningWrapperScript = (configPath) => [
+	"#!/usr/bin/env node",
+	"const { readFileSync } = require('node:fs');",
+	"const { spawnSync } = require('node:child_process');",
+	`const config = JSON.parse(readFileSync(${JSON.stringify(configPath)}, 'utf8'));`,
+	"const [kind, target, path] = process.argv.slice(2);",
+	"const args = config.args.map((arg) => arg.replaceAll('{path}', path).replaceAll('{target}', target).replaceAll('{kind}', kind));",
+	"const result = spawnSync(config.command, args, { cwd: config.cwd, env: process.env, stdio: 'inherit' });",
+	"if (result.error) {",
+	"  console.error(result.error.message);",
+	"  process.exit(1);",
+	"}",
+	"process.exit(result.status ?? 1);",
+	""
+].join("\n");
+var createNsisCodeSigningDirectiveCommand = (input) => `"${escapeNsis(process.execPath)}" "${escapeNsis(input.wrapperPath)}" "${input.kind}" "${input.target}" "%1"`;
+var createNsisCodeSigningDirectives = async (input) => {
+	const codeSigning = input.codeSigning;
+	if (codeSigning === void 0) return [];
+	const signsInstaller = require_vite_internals.includesWindowsCodeSigningTarget(codeSigning, "nsisInstaller");
+	const signsUninstaller = require_vite_internals.includesWindowsCodeSigningTarget(codeSigning, "nsisUninstaller");
+	if (!signsInstaller && !signsUninstaller) return [];
+	const scriptDirectory = (0, node_path.dirname)(input.scriptPath);
+	const configPath = (0, node_path.join)(scriptDirectory, `${(0, node_path.basename)(input.scriptPath)}.sign.json`);
+	const wrapperPath = (0, node_path.join)(scriptDirectory, `${(0, node_path.basename)(input.scriptPath)}.sign.cjs`);
+	await (0, node_fs_promises.writeFile)(configPath, `${JSON.stringify({
+		command: codeSigning.command,
+		args: codeSigning.args,
+		cwd: input.root
+	}, void 0, 2)}\n`);
+	await (0, node_fs_promises.writeFile)(wrapperPath, createNsisCodeSigningWrapperScript(configPath));
+	await (0, node_fs_promises.chmod)(wrapperPath, 493);
+	const lines = [];
+	if (signsInstaller) lines.push(`!finalize '${createNsisCodeSigningDirectiveCommand({
+		wrapperPath,
+		kind: "nsisInstaller",
+		target: input.target
+	})}' = 0`);
+	if (signsUninstaller) lines.push(`!uninstfinalize '${createNsisCodeSigningDirectiveCommand({
+		wrapperPath,
+		kind: "nsisUninstaller",
+		target: input.target
+	})}' = 0`);
+	return lines;
+};
 var reapplyPackWindowsResources = async (targets, resource, root, environment) => {
 	for (const target of targets) {
 		const descriptor = require_vite_internals.getMuonTargetDescriptor(target.target);
@@ -675,6 +870,86 @@ var reapplyPackWindowsResources = async (targets, resource, root, environment) =
 		}
 	}
 };
+var signPackWindowsExecutables = async (targets, codeSigning, root, environment, progress) => {
+	if (codeSigning === void 0) return;
+	progress?.({
+		phase: "pack",
+		status: "Signing Windows executables"
+	});
+	for (const target of targets) {
+		const descriptor = require_vite_internals.getMuonTargetDescriptor(target.target);
+		if (descriptor.os !== "windows") continue;
+		await require_vite_internals.signWindowsExecutable({
+			codeSigning,
+			kind: "runtime",
+			target: target.target,
+			path: (0, node_path.join)(target.outputPath, descriptor.runtimeExecutableName),
+			cwd: root,
+			environment
+		});
+		await require_vite_internals.signWindowsExecutable({
+			codeSigning,
+			kind: "launcher",
+			target: target.target,
+			path: target.launcherPath,
+			cwd: root,
+			environment
+		});
+	}
+};
+var createPortableBuildOptions = (input) => {
+	const buildOptions = {
+		root: input.project.root,
+		targets: input.targets,
+		allTargets: false,
+		outputRoot: input.outputRoot
+	};
+	if (input.project.pluginOptions !== void 0) {
+		if (input.project.viteOutputDirectory === void 0) throw new Error("Vite output directory could not be resolved.");
+		Object.assign(buildOptions, input.pluginBuildOptions);
+		const packagedAssetOptions = require_vite_internals.createVitePackagedAssetOptions(input.project.viteBase ?? "/");
+		buildOptions.assetSourcePath = input.project.viteOutputDirectory;
+		buildOptions.assetPrefix = packagedAssetOptions.assetPrefix;
+		if (packagedAssetOptions.browserStartPage !== void 0) buildOptions.browserStartPage = packagedAssetOptions.browserStartPage;
+	}
+	buildOptions.targets = input.targets;
+	buildOptions.allTargets = false;
+	buildOptions.outputRoot = input.outputRoot;
+	if (input.options.configPath !== void 0) buildOptions.configPath = input.options.configPath;
+	if (input.iconPath !== void 0) buildOptions.iconPath = input.iconPath;
+	if (input.options.appName !== void 0) buildOptions.appName = input.options.appName;
+	if (input.options.appId !== void 0) buildOptions.appId = input.options.appId;
+	if (input.options.packageDirectory !== void 0) buildOptions.packageDirectory = input.options.packageDirectory;
+	if (input.windowsResourceOptions !== void 0) buildOptions.windowsResource = input.windowsResourceOptions;
+	if (input.windowsCodeSigningOptions !== void 0) buildOptions.windowsCodeSigning = input.windowsCodeSigningOptions;
+	if (input.linuxDesktopOptions !== void 0) buildOptions.linuxDesktop = input.linuxDesktopOptions;
+	if (input.progress !== void 0) buildOptions.progress = input.progress;
+	buildOptions.environment = input.environment;
+	buildOptions.browserProfilePathOverride = portableProfilePath;
+	return buildOptions;
+};
+var buildPortableTargets = async (input) => {
+	if (input.targets.length === 0) return /* @__PURE__ */ new Map();
+	input.progress?.({
+		phase: "pack",
+		status: "Building portable distributions"
+	});
+	const build = await require_vite_internals.buildMuonApp(createPortableBuildOptions({
+		project: input.project,
+		pluginBuildOptions: input.pluginBuildOptions,
+		options: input.options,
+		outputRoot: (0, node_path.join)(input.packageBuildRoot, "portable-build"),
+		targets: input.targets,
+		windowsResourceOptions: input.windowsResourceOptions,
+		windowsCodeSigningOptions: input.windowsCodeSigningOptions,
+		linuxDesktopOptions: input.linuxDesktopOptions,
+		iconPath: input.iconPath,
+		environment: input.environment,
+		progress: input.progress
+	}));
+	await Promise.all(build.targets.map(writePortableInstallMetadata));
+	return new Map(build.targets.map((target) => [target.target, target]));
+};
 /**
 * Runs the muon build sequence and creates redistributable packages.
 *
@@ -703,6 +978,7 @@ var packMuonApp = async (options) => {
 		includeRuntimeHelper: linuxSandbox === "setuid"
 	};
 	const windowsResourceOptions = require_vite_internals.mergeMuonWindowsResourceOptions(options.windowsResource, pluginBuildOptions.windowsResource);
+	const windowsCodeSigningOptions = options.windowsCodeSigning !== void 0 ? options.windowsCodeSigning : pluginBuildOptions.windowsCodeSigning;
 	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;
@@ -711,8 +987,10 @@ var packMuonApp = async (options) => {
 	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 (windowsCodeSigningOptions !== void 0) buildOptions.windowsCodeSigning = windowsCodeSigningOptions;
 	if (linuxDesktopOptions !== void 0) buildOptions.linuxDesktop = linuxDesktopOptions;
 	if (progress !== void 0) buildOptions.progress = progress;
+	buildOptions.environment = environment;
 	const windowsResourceConfig = await require_vite_internals.readMuonConfigForWindowsResource(root, options.configPath);
 	const windowsResource = await require_vite_internals.resolveMuonWindowsResource({
 		root,
@@ -730,13 +1008,21 @@ var packMuonApp = async (options) => {
 			copyright: void 0
 		}
 	});
+	const windowsCodeSigning = require_vite_internals.resolveMuonWindowsCodeSigning({
+		muonConfig: windowsResourceConfig.config,
+		options: windowsCodeSigningOptions
+	});
 	progress?.({
 		phase: "pack",
 		status: "Building distributions"
 	});
 	const build = await require_vite_internals.runMuonBuildSequence(buildOptions, project);
-	if (options.packageVersion !== void 0) await reapplyPackWindowsResources(build.targets, windowsResource, root, environment);
+	if (options.packageVersion !== void 0) {
+		await reapplyPackWindowsResources(build.targets, windowsResource, root, environment);
+		await signPackWindowsExecutables(build.targets, windowsCodeSigning, root, environment, progress);
+	}
 	const typesByTarget = new Map(targetPlan.map((entry) => [entry.target, entry.types]));
+	const portableTargets = targetPlan.filter((entry) => entry.types.some(isPortablePackType)).map((entry) => entry.target);
 	await (0, node_fs_promises.rm)(packageBuildRoot, {
 		recursive: true,
 		force: true
@@ -750,6 +1036,23 @@ var packMuonApp = async (options) => {
 		force: true
 	});
 	await (0, node_fs_promises.mkdir)(artifactsRoot, { recursive: true });
+	const portableTargetsByTarget = await buildPortableTargets({
+		project,
+		pluginBuildOptions,
+		options,
+		packageBuildRoot,
+		targets: portableTargets,
+		windowsResourceOptions,
+		windowsCodeSigningOptions,
+		linuxDesktopOptions,
+		iconPath,
+		environment,
+		progress
+	});
+	if (options.packageVersion !== void 0) {
+		await reapplyPackWindowsResources([...portableTargetsByTarget.values()], windowsResource, root, environment);
+		await signPackWindowsExecutables([...portableTargetsByTarget.values()], windowsCodeSigning, root, environment, progress);
+	}
 	const artifacts = [];
 	const totalArtifacts = targetPlan.reduce((sum, entry) => sum + entry.types.length, 0);
 	let artifactIndex = 0;
@@ -760,10 +1063,17 @@ var packMuonApp = async (options) => {
 			status: `Packaging ${type} ${target.target} (${artifactIndex}/${totalArtifacts})`
 		});
 		let artifact;
-		if (type === "zip") artifact = await packageZip(target, metadata, artifactsRoot);
-		else if (type === "tar.gz") artifact = await packageTarGz(target, metadata, artifactsRoot);
-		else if (type === "deb") artifact = await packageDeb(root, target, metadata, artifactsRoot, packageBuildRoot, environment, linuxSandbox, progress);
-		else artifact = await packageNsis(root, target, metadata, windowsResource, artifactsRoot, packageBuildRoot, environment, progress);
+		if (type === "zip") {
+			const portableTarget = portableTargetsByTarget.get(target.target);
+			if (portableTarget === void 0) throw new Error(`Portable target was not built: ${target.target}`);
+			artifact = await packageZip(portableTarget, metadata, artifactsRoot);
+		} else if (type === "tar.gz") {
+			const portableTarget = portableTargetsByTarget.get(target.target);
+			if (portableTarget === void 0) throw new Error(`Portable target was not built: ${target.target}`);
+			artifact = await packageTarGz(portableTarget, metadata, artifactsRoot);
+		} else if (type === "deb") artifact = await packageDeb(root, target, metadata, artifactsRoot, packageBuildRoot, environment, linuxSandbox, progress);
+		else artifact = await packageNsis(root, target, metadata, windowsResource, windowsCodeSigning, artifactsRoot, packageBuildRoot, environment, progress);
+		if (artifact === void 0) continue;
 		artifacts.push(artifact);
 		progress?.({
 			phase: "pack",
@@ -783,8 +1093,8 @@ var packMuonApp = async (options) => {
 };
 //#endregion
 //#region src/generated/packageMetadata.ts
-var version = "0.11.0";
-var git_commit_hash = "db70f7643ac9fb1f61ab79f1de55c3dd8686de8d";
+var version = "0.13.0";
+var git_commit_hash = "8eedbe10e5a89eef8f7061d528518353bd09083e";
 //#endregion
 //#region src/cli.ts
 var readTargetValues = (value) => {
@@ -796,6 +1106,12 @@ var appendTargetValues = (value, previous) => {
 var appendPackTypeValues = (value, previous) => {
 	return [...previous ?? [], ...readTargetValues(value)];
 };
+var appendWindowsSignArgValue = (value, previous) => {
+	return [...previous ?? [], value];
+};
+var appendWindowsSignTargetValues = (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();
@@ -830,7 +1146,22 @@ var createLinuxDesktopOptions = (commandOptions) => {
 	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) => {
+var createWindowsCodeSigningOptions = (commandOptions, command) => {
+	if (command.getOptionValueSource("windowsCodeSigning") === "cli" && commandOptions.windowsCodeSigning === false) return false;
+	const args = commandOptions.windowsSignArg ?? [];
+	const targets = commandOptions.windowsSignTarget ?? [];
+	if (commandOptions.windowsSignCommand === void 0) {
+		if (args.length > 0 || targets.length > 0) throw new Error("--windows-sign-command is required when Windows signing arguments or targets are specified.");
+		return;
+	}
+	const options = {
+		command: commandOptions.windowsSignCommand,
+		args
+	};
+	if (targets.length > 0) options.targets = targets;
+	return options;
+};
+var runBuildCommand = async (commandOptions, command) => {
 	const targets = commandOptions.target;
 	if (commandOptions.all === true && targets.length > 0) throw new Error("Specify either --all or --target, not both.");
 	const buildOptions = {
@@ -844,6 +1175,8 @@ var runBuildCommand = async (commandOptions) => {
 	if (commandOptions.icon !== void 0) buildOptions.iconPath = commandOptions.icon;
 	const windowsResource = createWindowsResourceOptions(commandOptions);
 	if (windowsResource !== void 0) buildOptions.windowsResource = windowsResource;
+	const windowsCodeSigning = createWindowsCodeSigningOptions(commandOptions, command);
+	if (windowsCodeSigning !== void 0) buildOptions.windowsCodeSigning = windowsCodeSigning;
 	const linuxDesktop = createLinuxDesktopOptions(commandOptions);
 	if (linuxDesktop !== void 0) buildOptions.linuxDesktop = linuxDesktop;
 	if (commandOptions.outDir !== void 0) buildOptions.outputRoot = commandOptions.outDir;
@@ -862,7 +1195,7 @@ var runBuildCommand = async (commandOptions) => {
 	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) => {
+var runPackCommand = async (commandOptions, command) => {
 	const targets = commandOptions.target;
 	if (commandOptions.all === true && targets.length > 0) throw new Error("Specify either --all or --target, not both.");
 	const packOptions = {
@@ -876,6 +1209,8 @@ var runPackCommand = async (commandOptions) => {
 	if (commandOptions.icon !== void 0) packOptions.iconPath = commandOptions.icon;
 	const windowsResource = createWindowsResourceOptions(commandOptions);
 	if (windowsResource !== void 0) packOptions.windowsResource = windowsResource;
+	const windowsCodeSigning = createWindowsCodeSigningOptions(commandOptions, command);
+	if (windowsCodeSigning !== void 0) packOptions.windowsCodeSigning = windowsCodeSigning;
 	const linuxDesktop = createLinuxDesktopOptions(commandOptions);
 	if (linuxDesktop !== void 0) packOptions.linuxDesktop = linuxDesktop;
 	if (commandOptions.linuxSandbox !== void 0) packOptions.linuxSandbox = commandOptions.linuxSandbox;
@@ -974,11 +1309,11 @@ 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("--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("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("--windows-sign-command <command>", "Windows code signing command").option("--windows-sign-arg <arg>", "Windows code signing command argument", appendWindowsSignArgValue).option("--windows-sign-target <target>", "Windows code signing target or comma-separated targets", appendWindowsSignTargetValues).option("--no-windows-code-signing", "disable muon.json Windows signing").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, command) => {
+		await runBuildCommand(options, command);
 	});
-	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("--linux-sandbox <mode>", "Linux deb CEF sandbox mode: disabled, setuid").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);
+	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("--windows-sign-command <command>", "Windows code signing command").option("--windows-sign-arg <arg>", "Windows code signing command argument", appendWindowsSignArgValue).option("--windows-sign-target <target>", "Windows code signing target or comma-separated targets", appendWindowsSignTargetValues).option("--no-windows-code-signing", "disable muon.json Windows signing").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("--linux-sandbox <mode>", "Linux deb CEF sandbox mode: disabled, setuid").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, command) => {
+		await runPackCommand(options, command);
 	});
 	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);