muon-ui 0.2.0 → 0.4.0

package/dist/{build-BxDRaTmF.cjs → vite-options-C4evRLpv.cjs}

@@ -1,11 +1,11 @@
 /*!
 * name: muon-ui
-* version: 0.2.0
+* version: 0.4.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: 6251ff88aafa8ae873657f39aed1ebba2fa329a4
+* git.commit.hash: 44d549142c8cbfa13cb29d10be2568652a68bf50
 */
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -60,7 +60,7 @@ var getDefaultMuonPrepareTarget = (platform, architecture) => {
 	throw new Error(`Unsupported Muon prepare target: platform=${platform}, arch=${architecture}`);
 };
 var getPrepareExecutableName = (platform) => platform === "win32" ? "muon-prepare.exe" : "muon-prepare";
-var moduleDirectory$1 = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
+var moduleDirectory$2 = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
 var canExecute = async (path) => {
 	try {
 		await (0, node_fs_promises.access)(path, node_fs.constants.X_OK);
@@ -74,7 +74,7 @@ var resolveMuonPrepareExecutable = async (options) => {
 	if (explicit !== void 0 && explicit !== "") return explicit;
 	const executableName = getPrepareExecutableName(process.platform);
 	const target = getDefaultMuonPrepareTarget(process.platform, process.arch);
-	const candidates = [(0, node_path.join)(moduleDirectory$1, "native", target, executableName), (0, node_path.join)(moduleDirectory$1, "..", "dist", "native", target, executableName)];
+	const candidates = [(0, node_path.join)(moduleDirectory$2, "native", target, executableName), (0, node_path.join)(moduleDirectory$2, "..", "dist", "native", target, executableName)];
 	for (const candidate of candidates) if (await canExecute(candidate)) return candidate;
 	return candidates[0] ?? executableName;
 };
@@ -137,6 +137,36 @@ var runMuonPrepare = async (options) => {
 	};
 };
 //#endregion
+//#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 = (0, node_path.join)(root, ".gitignore");
+	let content = "";
+	try {
+		content = await (0, node_fs_promises.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 (0, node_fs_promises.writeFile)(gitignorePath, `${content}${separator}${muonGitignoreEntry}\n`);
+	return {
+		gitignorePath,
+		changed: true
+	};
+};
+//#endregion
 //#region ../node_modules/json5/dist/index.js
 var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	(function(global, factory) {
@@ -1414,7 +1444,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) => {
@@ -1447,7 +1477,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]),
@@ -1561,7 +1591,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 (0, node_fs_promises.stat)(path)).isFile();
 	} catch {
@@ -1577,10 +1607,10 @@ var resolveMuonConfigInputPath = async (configPath) => {
 			"muon.json"
 		]) {
 			const candidate = (0, node_path.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) => {
@@ -1793,13 +1823,13 @@ 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;
-var moduleDirectory = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
+var moduleDirectory$1 = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
 /**
 * Returns the host target used by muon build when no explicit target is passed.
 */
@@ -1849,7 +1879,7 @@ var buildMuonApp = async (options = {}) => {
 };
 var resolvePackageDirectory = (packageDirectory) => {
 	if (packageDirectory !== void 0) return (0, node_path.resolve)(packageDirectory);
-	return moduleDirectory;
+	return moduleDirectory$1;
 };
 var resolveBuildTargets = (options) => {
 	if (options.allTargets === true) return [...allTargets];
@@ -1857,7 +1887,7 @@ var resolveBuildTargets = (options) => {
 	return [getDefaultMuonBuildTarget()];
 };
 var resolveAssetInput = (root, assetSourcePath, assetPrefix, buildConfig) => {
-	const configuredAssetSourcePath = assetSourcePath === void 0 ? readConfigAssetFrom(buildConfig.config) : void 0;
+	const configuredAssetSourcePath = assetSourcePath === void 0 ? readConfigAssetSourcePath(buildConfig.config) : void 0;
 	return {
 		sourcePath: assetSourcePath !== void 0 ? (0, node_path.resolve)(root, assetSourcePath) : configuredAssetSourcePath !== void 0 ? (0, node_path.resolve)(buildConfig.directory, configuredAssetSourcePath) : (0, node_path.resolve)(root, "assets"),
 		prefix: normalizeZipPrefix(assetPrefix ?? "")
@@ -1888,24 +1918,24 @@ var readBuildConfig = async (root, configPath) => {
 		directory: (0, node_path.dirname)(resolvedConfigPath)
 	};
 };
-var readConfigAssetFrom = (sourceConfig) => {
+var readConfigAssetSourcePath = (sourceConfig) => {
 	const sourceAsset = sourceConfig.asset;
 	if (sourceAsset === void 0) return;
-	if (!isJsonObject(sourceAsset)) throw new Error("muon.json asset must be an object when present.");
-	const sourceAssetFrom = sourceAsset.from;
-	if (sourceAssetFrom === void 0) return;
-	if (typeof sourceAssetFrom !== "string") throw new Error("muon.json asset.from must be a string when present.");
-	return sourceAssetFrom;
+	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 = (0, node_path.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 = (0, node_path.join)(root, fileName);
-		if (await fileExists(candidatePath)) return candidatePath;
+		if (await fileExists$1(candidatePath)) return candidatePath;
 	}
 };
 var readJsonObjectFile = async (filePath, label) => {
@@ -1913,15 +1943,15 @@ var readJsonObjectFile = async (filePath, label) => {
 	try {
 		content = await (0, node_fs_promises.readFile)(filePath, "utf8");
 	} catch (error) {
-		throw new Error(`${label} could not be read: ${filePath}: ${getErrorMessage(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(error)}`);
+		throw new Error(`${label} could not be parsed: ${filePath}: ${getErrorMessage$1(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 buildMuonTarget = async (input) => {
@@ -2042,12 +2072,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
 		}
@@ -2081,7 +2111,7 @@ var statOrUndefined = async (path) => {
 		return;
 	}
 };
-var fileExists = async (path) => {
+var fileExists$1 = async (path) => {
 	try {
 		await (0, node_fs_promises.access)(path, node_fs.constants.F_OK);
 		return true;
@@ -2089,11 +2119,311 @@ 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 resolveFromRoot = (root, path) => (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(root, path);
+var moduleDirectory = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
+var defaultProjectConfigFileNames = [
+	"muon.json5",
+	"muon.jsonc",
+	"muon.json"
+];
+var muonRecycleExitCode = 88;
+/**
+* Resolves the muon-core runtime directory used by the Vite plugin.
+*
+* @param options Runtime path resolution inputs.
+* @returns Absolute or package-relative runtime directory path.
+*/
+var resolveMuonRuntimePath = ({ root, target, muonPath, packageDirectory = moduleDirectory }) => muonPath === void 0 ? (0, node_path.join)(packageDirectory, "runtime", target) : resolveFromRoot(root, muonPath);
+var getMuonExecutablePath = (runtimePath, platform) => (0, node_path.join)(runtimePath, platform === "win32" ? "muon-core.exe" : "muon-core");
+var getLaunchScriptFileName = (platform) => platform === "win32" ? "open-muon.cmd" : "open-muon.sh";
+var quotePosix = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+var getPlatformDirectoryName = (path, platform) => platform === "win32" ? node_path.win32.dirname(path) : (0, node_path.dirname)(path);
+var getOptionalPosixValue = (value) => value === void 0 ? "''" : quotePosix(value);
+var createPosixMuonLaunchScript = ({ muonExecutablePath, projectConfigPath, overrideConfigPath }) => `#!/usr/bin/env bash
+set -euo pipefail
+MUON_RECYCLE_EXIT_CODE=${muonRecycleExitCode}
+MUON_EXECUTABLE=${quotePosix(muonExecutablePath)}
+MUON_EXECUTABLE_DIRECTORY=${quotePosix(getPlatformDirectoryName(muonExecutablePath, "linux"))}
+MUON_PROJECT_CONFIG=${getOptionalPosixValue(projectConfigPath)}
+MUON_OVERRIDE_CONFIG=${quotePosix(overrideConfigPath)}
+
+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
+  echo "Muon startup failed: executable does not exist or is not executable: $MUON_EXECUTABLE" >&2
+  exit 1
+fi
+
+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"
+while true; do
+  set +e
+  "$MUON_EXECUTABLE" "\${MUON_CONFIG_ARGS[@]}"
+  MUON_EXIT_CODE=$?
+  set -e
+  if [[ "$MUON_EXIT_CODE" -ne "$MUON_RECYCLE_EXIT_CODE" ]]; then
+    exit "$MUON_EXIT_CODE"
+  fi
+done
+`;
+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_RECYCLE_EXIT_CODE=${muonRecycleExitCode}"
+set "MUON_EXECUTABLE=${escapeWindowsCmdValue(muonExecutablePath)}"
+set "MUON_EXECUTABLE_DIRECTORY=${escapeWindowsCmdValue(getPlatformDirectoryName(muonExecutablePath, "win32"))}"
+set "MUON_PROJECT_CONFIG=${getOptionalWindowsCmdValue(projectConfigPath)}"
+set "MUON_OVERRIDE_CONFIG=${escapeWindowsCmdValue(overrideConfigPath)}"
+
+if not exist "%MUON_EXECUTABLE%" (
+  echo Muon startup failed: executable does not exist: %MUON_EXECUTABLE% 1>&2
+  exit /b 1
+)
+
+if not exist "%MUON_OVERRIDE_CONFIG%" (
+  echo Muon startup failed: generated override config does not exist: %MUON_OVERRIDE_CONFIG% 1>&2
+  exit /b 1
+)
+
+pushd "%MUON_EXECUTABLE_DIRECTORY%"
+:muon_recycle_loop
+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%"
+if "%MUON_EXIT_CODE%"=="%MUON_RECYCLE_EXIT_CODE%" goto muon_recycle_loop
+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 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, enableDebugger) => {
+	const origin = new URL(startUrl).origin;
+	return {
+		...enableDebugger ? { cdp: { enable: true } } : {},
+		browser: {
+			startPage: startUrl,
+			...enableDebugger ? { keybind: {
+				devtools: "f12",
+				recycle: "ctrl+f12"
+			} } : {},
+			plugin: { allow: [`${origin}/**`] }
+		},
+		network: { allow: [`${origin}/**`, `${getWebSocketOrigin(startUrl)}/**`] }
+	};
+};
+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 false;
+	}
+	(0, node_fs.writeFileSync)(overrideConfigPath, `${JSON.stringify(createMuonOverrideConfig(startUrl, enableDebugger), null, 2)}\n`);
+	return true;
+};
+var createRuntimePaths = async (server, stagePath, platform, projectConfigPath) => {
+	const temporaryDirectory = await (0, node_fs_promises.mkdtemp)((0, node_path.join)((0, node_os.tmpdir)(), "muon-vite-"));
+	return {
+		temporaryDirectory,
+		launchScriptPath: (0, node_path.join)(temporaryDirectory, getLaunchScriptFileName(platform)),
+		overrideConfigPath: (0, node_path.join)(temporaryDirectory, "muon.vite.json"),
+		projectConfigPath,
+		muonExecutablePath: getMuonExecutablePath(stagePath, platform)
+	};
+};
+var fileExists = async (path) => {
+	try {
+		await (0, node_fs_promises.access)(path, node_fs.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 = (0, node_path.join)(server.config.root, fileName);
+		if (!await fileExists(candidatePath)) continue;
+		try {
+			if (!isJsonObject((0, import_dist.parse)(await (0, node_fs_promises.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 (0, node_fs_promises.writeFile)(paths.launchScriptPath, createMuonLaunchScript({
+		muonExecutablePath: paths.muonExecutablePath,
+		projectConfigPath: paths.projectConfigPath,
+		overrideConfigPath: paths.overrideConfigPath,
+		platform
+	}));
+	if (platform !== "win32") await (0, node_fs_promises.chmod)(paths.launchScriptPath, 448);
+};
+var quoteWindowsCommandArgument = (value) => `"${value.replaceAll("\"", "\\\"")}"`;
+var launchMuon = (paths, platform, server) => {
+	const child = (0, node_child_process.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 }) => {
+	await ensureMuonGitignoreEntry(server.config.root);
+	if (pluginOptions.open === false || server.httpServer === null) return;
+	const target = getDefaultMuonPrepareTarget(platform, architecture);
+	const preparedRuntime = await runMuonPrepare({
+		muonPath: resolveMuonRuntimePath({
+			root: server.config.root,
+			target,
+			muonPath: pluginOptions.muonPath
+		}),
+		cefPath: pluginOptions.cefPath === void 0 ? void 0 : resolveFromRoot(server.config.root, pluginOptions.cefPath),
+		stageDir: pluginOptions.stagePath === void 0 ? (0, node_path.resolve)(server.config.root, ".muon", target) : resolveFromRoot(server.config.root, pluginOptions.stagePath),
+		target,
+		cacheDir: environment.MUON_CACHE_DIR,
+		force: false,
+		quiet: false,
+		prepareExecutablePath: void 0,
+		environment,
+		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, await resolveProjectConfigPath(server));
+	await writeLaunchScript(paths, platform);
+	let cleanupPromise = void 0;
+	const cleanup = async () => {
+		if (cleanupPromise !== void 0) return cleanupPromise;
+		cleanupPromise = (async () => {
+			await (0, node_fs_promises.rm)(paths.temporaryDirectory, {
+				recursive: true,
+				force: true
+			});
+		})();
+		return cleanupPromise;
+	};
+	const originalClose = server.close.bind(server);
+	server.close = async () => {
+		try {
+			await originalClose();
+		} finally {
+			await cleanup();
+		}
+	};
+	server.httpServer.once("close", () => {
+		cleanup();
+	});
+	server.httpServer.once("listening", () => {
+		if (writeMuonOverrideConfig(server, paths.overrideConfigPath, pluginOptions.enableDebugger !== false)) launchMuon(paths, platform, server);
+	});
+};
+//#endregion
+//#region src/vite-options.ts
+/**
+* Metadata symbol used to recover `muon()` plugin options from `vite.config.*`.
+*/
+var muonVitePluginOptionsSymbol = Symbol.for("muon.vite.plugin.options");
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+var isMuonViteBuildOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return (value.targets === void 0 || isStringArray(value.targets)) && (value.allTargets === void 0 || typeof value.allTargets === "boolean") && (value.appName === void 0 || typeof value.appName === "string") && (value.outputRoot === void 0 || typeof value.outputRoot === "string") && (value.configPath === void 0 || typeof value.configPath === "string") && (value.packageDirectory === void 0 || typeof value.packageDirectory === "string") && (value.assetSalt === void 0 || value.assetSalt instanceof Uint8Array);
+};
+var isMuonVitePluginOptions = (value) => {
+	if (!isRecord(value)) return false;
+	return (value.muonPath === void 0 || typeof value.muonPath === "string") && (value.cefPath === void 0 || typeof value.cefPath === "string") && (value.stagePath === void 0 || typeof value.stagePath === "string") && (value.open === void 0 || typeof value.open === "boolean") && (value.enableDebugger === void 0 || typeof value.enableDebugger === "boolean") && (value.build === void 0 || typeof value.build === "boolean" || isMuonViteBuildOptions(value.build));
+};
+/**
+* Attaches raw Muon Vite plugin options to a plugin instance.
+*
+* @param plugin Plugin object.
+* @param options Raw plugin options.
+* @returns Plugin object with internal Muon metadata.
+*/
+var attachMuonVitePluginOptions = (plugin, options) => {
+	Object.defineProperty(plugin, muonVitePluginOptionsSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: { ...options },
+		writable: false
+	});
+	return plugin;
+};
+/**
+* Reads raw Muon Vite plugin options from a plugin instance.
+*
+* @param plugin Candidate plugin object.
+* @returns Attached Muon options, if present.
+*/
+var getMuonVitePluginOptions = (plugin) => {
+	if (!isRecord(plugin)) return;
+	const options = plugin[muonVitePluginOptionsSymbol];
+	return isMuonVitePluginOptions(options) ? options : void 0;
+};
+/**
+* Resolves nested Vite plugin option values into a flat list.
+*
+* @param pluginOptions Raw `plugins` field from a Vite config.
+* @returns Flat plugin object list.
+*/
+var flattenVitePluginOptions = async (pluginOptions) => {
+	const resolvedValue = await pluginOptions;
+	if (resolvedValue === null || resolvedValue === void 0 || !resolvedValue) return [];
+	if (Array.isArray(resolvedValue)) return (await Promise.all(resolvedValue.map((entry) => flattenVitePluginOptions(entry)))).flat();
+	return [resolvedValue];
+};
 //#endregion
+Object.defineProperty(exports, "attachMuonVitePluginOptions", {
+	enumerable: true,
+	get: function() {
+		return attachMuonVitePluginOptions;
+	}
+});
 Object.defineProperty(exports, "buildMuonApp", {
 	enumerable: true,
 	get: function() {
@@ -2118,23 +2448,59 @@ Object.defineProperty(exports, "embedMuonConfigInRuntime", {
 		return embedMuonConfigInRuntime;
 	}
 });
+Object.defineProperty(exports, "ensureMuonGitignoreEntry", {
+	enumerable: true,
+	get: function() {
+		return ensureMuonGitignoreEntry;
+	}
+});
+Object.defineProperty(exports, "flattenVitePluginOptions", {
+	enumerable: true,
+	get: function() {
+		return flattenVitePluginOptions;
+	}
+});
 Object.defineProperty(exports, "getDefaultMuonPrepareTarget", {
 	enumerable: true,
 	get: function() {
 		return getDefaultMuonPrepareTarget;
 	}
 });
+Object.defineProperty(exports, "getMuonExecutablePath", {
+	enumerable: true,
+	get: function() {
+		return getMuonExecutablePath;
+	}
+});
+Object.defineProperty(exports, "getMuonVitePluginOptions", {
+	enumerable: true,
+	get: function() {
+		return getMuonVitePluginOptions;
+	}
+});
 Object.defineProperty(exports, "require_dist", {
 	enumerable: true,
 	get: function() {
 		return require_dist;
 	}
 });
+Object.defineProperty(exports, "resolveMuonRuntimePath", {
+	enumerable: true,
+	get: function() {
+		return resolveMuonRuntimePath;
+	}
+});
 Object.defineProperty(exports, "runMuonPrepare", {
 	enumerable: true,
 	get: function() {
 		return runMuonPrepare;
 	}
 });
+Object.defineProperty(exports, "startMuonViteBrowserBridge", {
+	enumerable: true,
+	get: function() {
+		return startMuonViteBrowserBridge;
+	}
+});
 
-//# sourceMappingURL=build-BxDRaTmF.cjs.map
+//# sourceMappingURL=vite-options-C4evRLpv.cjs.map