muon-ui 0.1.0 → 0.3.0

package/dist/vite.mjs

@@ -1,11 +1,11 @@
 /*!
 * name: muon-ui
-* version: 0.1.0
+* version: 0.3.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: 35f9658786642562593735d3b589c1d7ab270ecf
+* git.commit.hash: e3c2c87d50dddb0bf6c2b4d5ebf0a37ab2d3b433
 */
 import { basename, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { constants, writeFileSync } from "node:fs";
@@ -1292,7 +1292,7 @@ var encodeTaggedBytes = (tag, bytes) => Buffer.concat([
 	encodeVarUint(BigInt(bytes.length)),
 	Buffer.from(bytes)
 ]);
-var isJsonObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isJsonObject$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isPath = (path, first, second) => path.length === 2 && path[0] === first && path[1] === second;
 var isHexString = (value) => value.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(value);
 var decodeHexString = (value) => {
@@ -1325,7 +1325,7 @@ var encodeTlvValue = (value, path) => {
 		encodeVarUint(BigInt(value.length)),
 		...value.map((entry) => encodeTlvValue(entry, path))
 	]);
-	if (isJsonObject$1(value)) {
+	if (isJsonObject$2(value)) {
 		const entries = Object.entries(value);
 		return Buffer.concat([
 			Buffer.from([tlvObjectTag]),
@@ -1439,7 +1439,7 @@ var findMuonBootstrapEmbeddedConfigSlot = (content) => {
 	if (candidate === void 0) throw new Error("Embedded muon-bootstrap config slot was not found.");
 	return candidate;
 };
-var fileExists$1 = async (path) => {
+var fileExists$2 = async (path) => {
 	try {
 		return (await stat(path)).isFile();
 	} catch {
@@ -1455,10 +1455,10 @@ var resolveMuonConfigInputPath = async (configPath) => {
 			"muon.json"
 		]) {
 			const candidate = join(directory, fileName);
-			if (await fileExists$1(candidate)) return candidate;
+			if (await fileExists$2(candidate)) return candidate;
 		}
 	}
-	if (!await fileExists$1(configPath)) throw new Error(`muon config does not exist: ${configPath}`);
+	if (!await fileExists$2(configPath)) throw new Error(`muon config does not exist: ${configPath}`);
 	return configPath;
 };
 var readMuonConfigInput = async (configPath) => {
@@ -1769,8 +1769,9 @@ var defaultConfigFileNames = [
 	"muon.jsonc",
 	"muon.json"
 ];
-var appConfigFromPath = "./assets.zip";
+var appConfigSourcePath = "./assets.zip";
 var defaultAppName = "muon-app";
+var muonLicenseFileName = "LICENSE_muon";
 var directoryMode = 493;
 var executableMode = 493;
 var assetSaltByteLength = 16;
@@ -1800,8 +1801,8 @@ var buildMuonApp = async (options = {}) => {
 	const targets = resolveBuildTargets(options);
 	const outputRoot = resolve(root, options.outputRoot ?? ".");
 	const appName = await resolveAppName(root, options.appName);
-	const assetInput = resolveAssetInput(root, options.assetSourcePath, options.assetPrefix);
-	const sourceConfig = await readBuildConfig(root, options.configPath);
+	const buildConfig = await readBuildConfig(root, options.configPath);
+	const assetInput = resolveAssetInput(root, options.assetSourcePath, options.assetPrefix, buildConfig);
 	const salt = Buffer.from(options.assetSalt ?? randomBytes(assetSaltByteLength));
 	const results = [];
 	for (const target of targets) {
@@ -1811,7 +1812,7 @@ var buildMuonApp = async (options = {}) => {
 			appName,
 			target,
 			assetInput,
-			sourceConfig,
+			sourceConfig: buildConfig.config,
 			salt
 		});
 		results.push(result);
@@ -1831,9 +1832,10 @@ var resolveBuildTargets = (options) => {
 	if (options.targets !== void 0 && options.targets.length > 0) return [...new Set(options.targets.map((target) => normalizeMuonBuildTarget(target)))];
 	return [getDefaultMuonBuildTarget()];
 };
-var resolveAssetInput = (root, assetSourcePath, assetPrefix) => {
+var resolveAssetInput = (root, assetSourcePath, assetPrefix, buildConfig) => {
+	const configuredAssetSourcePath = assetSourcePath === void 0 ? readConfigAssetSourcePath(buildConfig.config) : void 0;
 	return {
-		sourcePath: resolve(root, assetSourcePath ?? "assets"),
+		sourcePath: assetSourcePath !== void 0 ? resolve(root, assetSourcePath) : configuredAssetSourcePath !== void 0 ? resolve(buildConfig.directory, configuredAssetSourcePath) : resolve(root, "assets"),
 		prefix: normalizeZipPrefix(assetPrefix ?? "")
 	};
 };
@@ -1843,7 +1845,7 @@ var normalizeZipPrefix = (prefix) => {
 };
 var resolveAppName = async (root, appName) => {
 	if (appName !== void 0) return sanitizeAppName(appName);
-	const packageJson = await readJsonObjectFile(join(root, "package.json"));
+	const packageJson = await readJsonObjectFile(join(root, "package.json"), "package.json");
 	const packageName = typeof packageJson.name === "string" ? packageJson.name : defaultAppName;
 	return sanitizeAppName(packageName.startsWith("@") ? packageName.slice(packageName.indexOf("/") + 1) : packageName);
 };
@@ -1853,23 +1855,49 @@ var sanitizeAppName = (name) => {
 };
 var readBuildConfig = async (root, configPath) => {
 	const resolvedConfigPath = await resolveConfigPath(root, configPath);
-	if (resolvedConfigPath === void 0) return {};
-	return readJsonObjectFile(resolvedConfigPath);
+	if (resolvedConfigPath === void 0) return {
+		config: {},
+		directory: root
+	};
+	return {
+		config: await readJsonObjectFile(resolvedConfigPath, "Muon config file"),
+		directory: dirname(resolvedConfigPath)
+	};
+};
+var readConfigAssetSourcePath = (sourceConfig) => {
+	const sourceAsset = sourceConfig.asset;
+	if (sourceAsset === void 0) return;
+	if (!isJsonObject$1(sourceAsset)) throw new Error("muon.json asset must be an object when present.");
+	const sourceAssetPath = sourceAsset.sourcePath;
+	if (sourceAssetPath === void 0) return;
+	if (typeof sourceAssetPath !== "string") throw new Error("muon.json asset.sourcePath must be a string when present.");
+	return sourceAssetPath;
 };
 var resolveConfigPath = async (root, configPath) => {
 	if (configPath !== void 0) {
 		const resolvedPath = resolve(root, configPath);
-		if (await fileExists(resolvedPath)) return resolvedPath;
+		if (await fileExists$1(resolvedPath)) return resolvedPath;
 		throw new Error(`Muon config file does not exist: ${resolvedPath}`);
 	}
 	for (const fileName of defaultConfigFileNames) {
 		const candidatePath = join(root, fileName);
-		if (await fileExists(candidatePath)) return candidatePath;
+		if (await fileExists$1(candidatePath)) return candidatePath;
 	}
 };
-var readJsonObjectFile = async (filePath) => {
-	const parsed = (0, import_dist.parse)(await readFile(filePath, "utf8"));
-	if (!isJsonObject(parsed)) throw new Error(`Expected JSON object in ${filePath}`);
+var readJsonObjectFile = async (filePath, label) => {
+	let content;
+	try {
+		content = await readFile(filePath, "utf8");
+	} catch (error) {
+		throw new Error(`${label} could not be read: ${filePath}: ${getErrorMessage$1(error)}`);
+	}
+	let parsed;
+	try {
+		parsed = (0, import_dist.parse)(content);
+	} catch (error) {
+		throw new Error(`${label} could not be parsed: ${filePath}: ${getErrorMessage$1(error)}`);
+	}
+	if (!isJsonObject$1(parsed)) throw new Error(`${label} must contain a JSON object: ${filePath}`);
 	return parsed;
 };
 var buildMuonTarget = async (input) => {
@@ -1924,7 +1952,7 @@ var verifyTargetInputs = async (input) => {
 	await assertDirectory(input.sourceRuntimePath, `Muon runtime for ${input.target}`);
 	await assertFile(input.sourceBootstrapPath, `Muon bootstrap for ${input.target}`);
 	for (const fileName of input.descriptor.runtimeFiles) await assertFile(join(input.sourceRuntimePath, fileName), `Muon runtime file ${fileName} for ${input.target}`);
-	await assertFile(join(input.sourceRuntimePath, "THIRD_PARTY_NOTICES.md"), `Muon third-party notices for ${input.target}`);
+	await assertFile(join(input.sourceRuntimePath, muonLicenseFileName), `Muon license file for ${input.target}`);
 };
 var getLauncherFileName = (appName, descriptor) => {
 	if (descriptor.launcherExtension.length > 0 && !appName.endsWith(descriptor.launcherExtension)) return `${appName}${descriptor.launcherExtension}`;
@@ -1932,21 +1960,33 @@ var getLauncherFileName = (appName, descriptor) => {
 };
 var copyRuntimeFiles = async (sourceRuntimePath, outputPath, descriptor) => {
 	for (const fileName of descriptor.runtimeFiles) await copyFile(join(sourceRuntimePath, fileName), join(outputPath, fileName));
-	await copyFile(join(sourceRuntimePath, "THIRD_PARTY_NOTICES.md"), join(outputPath, "THIRD_PARTY_NOTICES.md"));
+	await copyFile(join(sourceRuntimePath, muonLicenseFileName), join(outputPath, muonLicenseFileName));
 };
 var writeAssetArchive = async (input, outputPath, salt) => {
-	await assertDirectory(input.sourcePath, "Muon asset source");
-	const entries = await collectZipEntries(input.sourcePath, input.prefix);
-	if (entries.length === 0) throw new Error(`Muon asset source has no files: ${input.sourcePath}`);
-	const archive = createZipArchive(entries);
+	const sourceStats = await statOrUndefined(input.sourcePath);
+	if (sourceStats === void 0) throw new Error(`Muon asset source does not exist: ${input.sourcePath}`);
+	const archive = sourceStats.isDirectory() ? await createAssetArchiveFromDirectory(input) : sourceStats.isFile() ? await readFile(input.sourcePath) : void 0;
+	if (archive === void 0) throw new Error(`Muon asset source is not a directory or file: ${input.sourcePath}`);
 	await writeFile(outputPath, archive);
 	return {
 		path: outputPath,
 		signature: createHash("sha1").update(archive).update(salt).digest("hex"),
 		salt: salt.toString("hex"),
-		entryCount: entries.length
+		entryCount: sourceStats.isDirectory() ? readZipEntryCount(archive, outputPath) : readZipEntryCount(archive, input.sourcePath)
 	};
 };
+var createAssetArchiveFromDirectory = async (input) => {
+	const entries = await collectZipEntries(input.sourcePath, input.prefix);
+	if (entries.length === 0) throw new Error(`Muon asset source has no files: ${input.sourcePath}`);
+	return createZipArchive(entries);
+};
+var readZipEntryCount = (archive, sourcePath) => {
+	const endSignature = 101010256;
+	const lastPossibleOffset = archive.length - 22;
+	const firstPossibleOffset = Math.max(0, lastPossibleOffset - 65535);
+	for (let offset = lastPossibleOffset; offset >= firstPossibleOffset; offset -= 1) if (archive.readUInt32LE(offset) === endSignature) return archive.readUInt16LE(offset + 10);
+	throw new Error(`Muon asset ZIP could not be read: ${sourcePath}`);
+};
 var collectZipEntries = async (sourcePath, prefix) => {
 	const entries = [];
 	const walk = async (directoryPath) => {
@@ -1978,12 +2018,12 @@ var createZipArchive = (entries) => {
 };
 var createEmbeddedConfig = (sourceConfig, asset) => {
 	const sourceAsset = sourceConfig.asset;
-	if (sourceAsset !== void 0 && !isJsonObject(sourceAsset)) throw new Error("muon.json asset must be an object when present.");
+	if (sourceAsset !== void 0 && !isJsonObject$1(sourceAsset)) throw new Error("muon.json asset must be an object when present.");
 	return {
 		...sourceConfig,
 		asset: {
 			...sourceAsset ?? {},
-			from: appConfigFromPath,
+			sourcePath: appConfigSourcePath,
 			signature: asset.signature,
 			salt: asset.salt
 		}
@@ -2003,14 +2043,21 @@ var withTemporaryConfig = async (config, callback) => {
 	}
 };
 var assertDirectory = async (path, label) => {
-	const stats = await stat(path).catch(() => void 0);
+	const stats = await statOrUndefined(path);
 	if (stats === void 0 || !stats.isDirectory()) throw new Error(`${label} directory does not exist: ${path}`);
 };
 var assertFile = async (path, label) => {
-	const stats = await stat(path).catch(() => void 0);
+	const stats = await statOrUndefined(path);
 	if (stats === void 0 || !stats.isFile()) throw new Error(`${label} file does not exist: ${path}`);
 };
-var fileExists = async (path) => {
+var statOrUndefined = async (path) => {
+	try {
+		return await stat(path);
+	} catch {
+		return;
+	}
+};
+var fileExists$1 = async (path) => {
 	try {
 		await access(path, constants.F_OK);
 		return true;
@@ -2018,17 +2065,49 @@ var fileExists = async (path) => {
 		return false;
 	}
 };
-var isJsonObject = (value) => {
+var isJsonObject$1 = (value) => {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 };
+var getErrorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
 //#endregion
-//#region src/vite-internals.ts
-var getServerOpenValue = (server) => {
-	const open = server.config.server.open;
-	return open === true || typeof open === "string" ? open : false;
+//#region src/gitignore.ts
+var muonGitignoreEntry = ".muon/";
+var isMissingFileError = (error) => error instanceof Error && error.code === "ENOENT";
+var hasMuonGitignoreEntry = (content) => content.split(/\r?\n/).map((line) => line.trim()).some((line) => line === muonGitignoreEntry || line === `/${muonGitignoreEntry}` || line === ".muon" || line === "/.muon");
+/**
+* Adds the Muon staging directory to a project .gitignore file.
+*
+* @param root Project root containing the .gitignore file.
+* @returns Gitignore update result.
+*/
+var ensureMuonGitignoreEntry = async (root) => {
+	const gitignorePath = join(root, ".gitignore");
+	let content = "";
+	try {
+		content = await readFile(gitignorePath, "utf8");
+	} catch (error) {
+		if (!isMissingFileError(error)) throw error;
+	}
+	if (hasMuonGitignoreEntry(content)) return {
+		gitignorePath,
+		changed: false
+	};
+	const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+	await writeFile(gitignorePath, `${content}${separator}${muonGitignoreEntry}\n`);
+	return {
+		gitignorePath,
+		changed: true
+	};
 };
+//#endregion
+//#region src/vite-internals.ts
 var resolveFromRoot = (root, path) => isAbsolute(path) ? path : resolve(root, path);
 var moduleDirectory = typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
+var defaultProjectConfigFileNames = [
+	"muon.json5",
+	"muon.jsonc",
+	"muon.json"
+];
 /**
 * Resolves the muon-core runtime directory used by the Vite plugin.
 *
@@ -2040,16 +2119,21 @@ var getMuonExecutablePath = (runtimePath, platform) => join(runtimePath, platfor
 var getLaunchScriptFileName = (platform) => platform === "win32" ? "open-muon.cmd" : "open-muon.sh";
 var quotePosix = (value) => `'${value.replaceAll("'", "'\\''")}'`;
 var getPlatformDirectoryName = (path, platform) => platform === "win32" ? win32.dirname(path) : dirname(path);
+var getOptionalPosixValue = (value) => value === void 0 ? "''" : quotePosix(value);
 var createPosixMuonLaunchScript = ({ muonExecutablePath, projectConfigPath, overrideConfigPath }) => `#!/usr/bin/env bash
 set -euo pipefail
 MUON_EXECUTABLE=${quotePosix(muonExecutablePath)}
 MUON_EXECUTABLE_DIRECTORY=${quotePosix(getPlatformDirectoryName(muonExecutablePath, "linux"))}
-MUON_PROJECT_CONFIG=${quotePosix(projectConfigPath)}
+MUON_PROJECT_CONFIG=${getOptionalPosixValue(projectConfigPath)}
 MUON_OVERRIDE_CONFIG=${quotePosix(overrideConfigPath)}
 
-if [[ ! -f "$MUON_PROJECT_CONFIG" ]]; then
-  echo "Muon startup failed: project config does not exist: $MUON_PROJECT_CONFIG" >&2
-  exit 1
+MUON_CONFIG_ARGS=()
+if [[ -n "$MUON_PROJECT_CONFIG" ]]; then
+  if [[ ! -f "$MUON_PROJECT_CONFIG" ]]; then
+    echo "Muon startup failed: project config does not exist: $MUON_PROJECT_CONFIG" >&2
+    exit 1
+  fi
+  MUON_CONFIG_ARGS+=("-c" "$MUON_PROJECT_CONFIG")
 fi
 
 if [[ ! -x "$MUON_EXECUTABLE" ]]; then
@@ -2061,23 +2145,20 @@ if [[ ! -f "$MUON_OVERRIDE_CONFIG" ]]; then
   echo "Muon startup failed: generated override config does not exist: $MUON_OVERRIDE_CONFIG" >&2
   exit 1
 fi
+MUON_CONFIG_ARGS+=("-c" "$MUON_OVERRIDE_CONFIG")
 
 cd "$MUON_EXECUTABLE_DIRECTORY"
-exec "$MUON_EXECUTABLE" -c "$MUON_PROJECT_CONFIG" -c "$MUON_OVERRIDE_CONFIG"
+exec "$MUON_EXECUTABLE" "\${MUON_CONFIG_ARGS[@]}"
 `;
 var escapeWindowsCmdValue = (value) => value.replaceAll("%", "%%").replaceAll("\r", "").replaceAll("\n", "");
+var getOptionalWindowsCmdValue = (value) => value === void 0 ? "" : escapeWindowsCmdValue(value);
 var createWindowsMuonLaunchScript = ({ muonExecutablePath, projectConfigPath, overrideConfigPath }) => `@echo off
 setlocal
 set "MUON_EXECUTABLE=${escapeWindowsCmdValue(muonExecutablePath)}"
 set "MUON_EXECUTABLE_DIRECTORY=${escapeWindowsCmdValue(getPlatformDirectoryName(muonExecutablePath, "win32"))}"
-set "MUON_PROJECT_CONFIG=${escapeWindowsCmdValue(projectConfigPath)}"
+set "MUON_PROJECT_CONFIG=${getOptionalWindowsCmdValue(projectConfigPath)}"
 set "MUON_OVERRIDE_CONFIG=${escapeWindowsCmdValue(overrideConfigPath)}"
 
-if not exist "%MUON_PROJECT_CONFIG%" (
-  echo Muon startup failed: project config does not exist: %MUON_PROJECT_CONFIG% 1>&2
-  exit /b 1
-)
-
 if not exist "%MUON_EXECUTABLE%" (
   echo Muon startup failed: executable does not exist: %MUON_EXECUTABLE% 1>&2
   exit /b 1
@@ -2089,52 +2170,83 @@ if not exist "%MUON_OVERRIDE_CONFIG%" (
 )
 
 pushd "%MUON_EXECUTABLE_DIRECTORY%"
-"%MUON_EXECUTABLE%" -c "%MUON_PROJECT_CONFIG%" -c "%MUON_OVERRIDE_CONFIG%"
+if defined MUON_PROJECT_CONFIG (
+  if not exist "%MUON_PROJECT_CONFIG%" (
+    echo Muon startup failed: project config does not exist: %MUON_PROJECT_CONFIG% 1>&2
+    popd
+    exit /b 1
+  )
+  "%MUON_EXECUTABLE%" -c "%MUON_PROJECT_CONFIG%" -c "%MUON_OVERRIDE_CONFIG%"
+) else (
+  "%MUON_EXECUTABLE%" -c "%MUON_OVERRIDE_CONFIG%"
+)
 set "MUON_EXIT_CODE=%ERRORLEVEL%"
 popd
 exit /b %MUON_EXIT_CODE%
 `;
 var createMuonLaunchScript = (options) => options.platform === "win32" ? createWindowsMuonLaunchScript(options) : createPosixMuonLaunchScript(options);
 var getBaseUrl = (server) => server.resolvedUrls?.local[0] ?? server.resolvedUrls?.network[0];
-var getStartUrl = (server, openValue) => {
-	const baseUrl = getBaseUrl(server);
-	if (baseUrl === void 0) return;
-	return typeof openValue === "string" ? new URL(openValue, baseUrl).href : baseUrl;
-};
 var getWebSocketOrigin = (startUrl) => {
 	const url = new URL(startUrl);
 	if (url.protocol === "https:") url.protocol = "wss:";
 	else if (url.protocol === "http:") url.protocol = "ws:";
 	return url.origin;
 };
-var createMuonOverrideConfig = (startUrl) => {
+var createMuonOverrideConfig = (startUrl, enableDebugger) => {
 	const origin = new URL(startUrl).origin;
 	return {
+		...enableDebugger ? { cdp: { enable: true } } : {},
 		browser: {
 			startPage: startUrl,
+			...enableDebugger ? { keybind: { devtools: "f12" } } : {},
 			plugin: { allow: [`${origin}/**`] }
 		},
 		network: { allow: [`${origin}/**`, `${getWebSocketOrigin(startUrl)}/**`] }
 	};
 };
-var writeMuonOverrideConfig = (server, openValue, overrideConfigPath) => {
-	const startUrl = getStartUrl(server, openValue);
+var writeMuonOverrideConfig = (server, overrideConfigPath, enableDebugger) => {
+	const startUrl = getBaseUrl(server);
 	if (startUrl === void 0) {
 		server.config.logger.warn("Muon Vite plugin could not resolve a Vite URL.");
-		return;
+		return false;
 	}
-	writeFileSync(overrideConfigPath, `${JSON.stringify(createMuonOverrideConfig(startUrl), null, 2)}\n`);
+	writeFileSync(overrideConfigPath, `${JSON.stringify(createMuonOverrideConfig(startUrl, enableDebugger), null, 2)}\n`);
+	return true;
 };
-var createRuntimePaths = async (server, stagePath, platform) => {
+var createRuntimePaths = async (server, stagePath, platform, projectConfigPath) => {
 	const temporaryDirectory = await mkdtemp(join(tmpdir(), "muon-vite-"));
 	return {
 		temporaryDirectory,
 		launchScriptPath: join(temporaryDirectory, getLaunchScriptFileName(platform)),
 		overrideConfigPath: join(temporaryDirectory, "muon.vite.json"),
-		projectConfigPath: join(server.config.root, "muon.json"),
+		projectConfigPath,
 		muonExecutablePath: getMuonExecutablePath(stagePath, platform)
 	};
 };
+var fileExists = async (path) => {
+	try {
+		await access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+var resolveProjectConfigPath = async (server) => {
+	for (const fileName of defaultProjectConfigFileNames) {
+		const candidatePath = join(server.config.root, fileName);
+		if (!await fileExists(candidatePath)) continue;
+		try {
+			if (!isJsonObject((0, import_dist.parse)(await readFile(candidatePath, "utf8")))) throw new Error("muon config root must be an object");
+			return candidatePath;
+		} catch (error) {
+			server.config.logger.warn(`Muon project config will be ignored because it could not be read or parsed: ${candidatePath}: ${getErrorMessage(error)}`);
+			return;
+		}
+	}
+	server.config.logger.warn(`Muon project config was not found in ${server.config.root}; launching with generated Vite config only.`);
+};
 var writeLaunchScript = async (paths, platform) => {
 	await writeFile(paths.launchScriptPath, createMuonLaunchScript({
 		muonExecutablePath: paths.muonExecutablePath,
@@ -2144,9 +2256,26 @@ var writeLaunchScript = async (paths, platform) => {
 	}));
 	if (platform !== "win32") await chmod(paths.launchScriptPath, 448);
 };
+var quoteWindowsCommandArgument = (value) => `"${value.replaceAll("\"", "\\\"")}"`;
+var launchMuon = (paths, platform, server) => {
+	const child = spawn(platform === "win32" ? "cmd.exe" : paths.launchScriptPath, platform === "win32" ? [
+		"/d",
+		"/s",
+		"/c",
+		quoteWindowsCommandArgument(paths.launchScriptPath)
+	] : [], {
+		detached: true,
+		stdio: "ignore",
+		windowsHide: false
+	});
+	child.once("error", (error) => {
+		server.config.logger.warn(`Muon startup failed: ${getErrorMessage(error)}`);
+	});
+	child.unref();
+};
 var startMuonViteBrowserBridge = async ({ server, pluginOptions, platform, architecture, environment }) => {
-	const openValue = getServerOpenValue(server);
-	if (openValue === false || server.httpServer === null) return;
+	await ensureMuonGitignoreEntry(server.config.root);
+	if (pluginOptions.open === false || server.httpServer === null) return;
 	const target = getDefaultMuonPrepareTarget(platform, architecture);
 	const preparedRuntime = await runMuonPrepare({
 		muonPath: resolveMuonRuntimePath({
@@ -2165,16 +2294,12 @@ var startMuonViteBrowserBridge = async ({ server, pluginOptions, platform, archi
 		cwd: server.config.root
 	});
 	if (preparedRuntime.stagePath === void 0) throw new Error("muon-prepare did not return a staged runtime path.");
-	const paths = await createRuntimePaths(server, preparedRuntime.stagePath, platform);
+	const paths = await createRuntimePaths(server, preparedRuntime.stagePath, platform, await resolveProjectConfigPath(server));
 	await writeLaunchScript(paths, platform);
-	const previousBrowser = environment.BROWSER;
-	environment.BROWSER = paths.launchScriptPath;
 	let cleanupPromise = void 0;
 	const cleanup = async () => {
 		if (cleanupPromise !== void 0) return cleanupPromise;
 		cleanupPromise = (async () => {
-			if (previousBrowser === void 0) delete environment.BROWSER;
-			else environment.BROWSER = previousBrowser;
 			await rm(paths.temporaryDirectory, {
 				recursive: true,
 				force: true
@@ -2194,15 +2319,15 @@ var startMuonViteBrowserBridge = async ({ server, pluginOptions, platform, archi
 		cleanup();
 	});
 	server.httpServer.once("listening", () => {
-		writeMuonOverrideConfig(server, openValue, paths.overrideConfigPath);
+		if (writeMuonOverrideConfig(server, paths.overrideConfigPath, pluginOptions.enableDebugger !== false)) launchMuon(paths, platform, server);
 	});
 };
 //#endregion
 //#region src/vite.ts
 /**
-* Creates a Vite plugin that launches Muon through Vite's server.open flow.
+* Creates a Vite plugin that launches Muon during Vite dev startup.
 *
-* @param options Muon runtime location used for development startup.
+* @param options Muon plugin options used for development startup and build.
 * @returns Vite plugin instance.
 */
 var muon = (options = {}) => {