muon-ui 0.7.0 → 0.9.0

package/dist/vite.cjs

@@ -1,37 +1,461 @@
 /*!
 * name: muon-ui
-* version: 0.7.0
+* version: 0.9.0
 * description: A multi-platform GUI application framework that uses CEF as its backend
 * author: Kouji Matsui (@kekyo@mi.kekyo.net)
 * license: MIT
 * repository.url: https://github.com/kekyo/muon-ui.git
-* git.commit.hash: fe80718aaa617c0c0ea5c816bbe38d22bf2e8402
+* git.commit.hash: 3437b522a51d8772713b72722b109c5ff30fc711
 */
-const require_vite_options = require("./vite-options-FFh0NWUa.cjs");
+const require_vite_internals = require("./vite-internals-HXgH7b5M.cjs");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
+let node_crypto = require("node:crypto");
+//#region src/capability.ts
+var virtualModulePrefix = "\0muon-capability:";
+var moduleNamePattern = /^[A-Za-z_$][A-Za-z0-9_$]*:[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/u;
+var jsIdentifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/u;
+var normalizePath = (path) => (path.split("?")[0] ?? "").replaceAll("\\", "/");
+var hashCapabilityRule = (index, rule) => `cap-${(0, node_crypto.createHash)("sha1").update(JSON.stringify({
+	index,
+	pluginName: rule.pluginName,
+	sources: [...rule.sources ?? []],
+	packages: [...rule.packages ?? []],
+	allow: [...rule.allow]
+})).digest("hex").slice(0, 16)}`;
+var parseCapabilitySpecifier = (source) => {
+	if (!moduleNamePattern.test(source)) return;
+	const separator = source.indexOf(":");
+	return {
+		moduleName: source,
+		namespace: `${source.slice(0, separator)}.${source.slice(separator + 1)}`
+	};
+};
+var escapeRegExp = (source) => source.replace(/[\\^$+?.()|[\]{}]/gu, "\\$&");
+var globToRegExp = (glob, separator) => {
+	let source = "^";
+	for (let index = 0; index < glob.length; index += 1) {
+		const current = glob[index] ?? "";
+		const next = glob[index + 1];
+		if (current === "*" && next === "*") {
+			source += ".*";
+			index += 1;
+			continue;
+		}
+		if (current === "*") {
+			source += `[^${escapeRegExp(separator)}]*`;
+			continue;
+		}
+		source += escapeRegExp(current);
+	}
+	source += "$";
+	return new RegExp(source, "u");
+};
+var isGlobMatch = (glob, value, separator) => globToRegExp(glob, separator).test(value);
+var toRootRelativeImporter = (root, importer) => normalizePath((0, node_path.relative)(root, importer));
+var readPackageName = (packageJsonPath) => {
+	try {
+		const parsed = JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf8"));
+		return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && typeof parsed.name === "string" ? parsed.name : void 0;
+	} catch {
+		return;
+	}
+};
+var getImporterPackageName = (root, importer) => {
+	const normalizedRoot = normalizePath(root);
+	const rootPackageJsonPath = (0, node_path.join)(root, "package.json");
+	let directory = (0, node_path.dirname)(normalizePath(importer));
+	for (;;) {
+		const packageJsonPath = (0, node_path.join)(directory, "package.json");
+		if (packageJsonPath !== rootPackageJsonPath && (0, node_fs.existsSync)(packageJsonPath)) return readPackageName(packageJsonPath);
+		if (normalizePath(directory) === normalizedRoot) return;
+		const parent = (0, node_path.dirname)(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+};
+var matchesCapabilityRuleImporter = (rule, root, importer) => {
+	const relativeImporter = toRootRelativeImporter(root, importer);
+	if (rule.sources?.some((pattern) => isGlobMatch(normalizePath(pattern), relativeImporter, "/")) ?? false) return true;
+	const packageName = getImporterPackageName(root, importer);
+	return packageName === void 0 ? false : rule.packages?.includes(packageName) ?? false;
+};
+var hasNamespaceFunctionAllow = (namespace, allow) => allow.some((entry) => {
+	if (entry.startsWith(`${namespace}.`)) return true;
+	return isGlobMatch(entry, `${namespace}.placeholder`, ".");
+});
+var getExactExportName = (namespace, functionPath) => {
+	const prefix = `${namespace}.`;
+	if (!functionPath.startsWith(prefix)) return;
+	const name = functionPath.slice(prefix.length);
+	if (!jsIdentifierPattern.test(name)) return;
+	return name;
+};
+var getExportedFunctions = (namespace, allow) => allow.flatMap((functionPath) => {
+	const exportName = getExactExportName(namespace, functionPath);
+	return exportName === void 0 ? [] : [[exportName, functionPath]];
+});
+var createRuleRuntimeEntry = (rule, index) => ({
+	id: hashCapabilityRule(index, rule),
+	allow: [...rule.allow]
+});
+var validateCapabilityRule = (rule) => {
+	if ((rule.sources === void 0 || rule.sources.length === 0) && (rule.packages === void 0 || rule.packages.length === 0)) throw new Error("Muon capability import rule requires sources or packages.");
+};
+var createModuleVirtualId = (rule) => `${virtualModulePrefix}${rule.index}:${rule.moduleName}`;
+var parseModuleVirtualId = (id) => {
+	if (!id.startsWith(virtualModulePrefix)) return;
+	const payload = id.slice(17);
+	const separator = payload.indexOf(":");
+	if (separator <= 0) return;
+	const index = Number.parseInt(payload.slice(0, separator), 10);
+	if (!Number.isInteger(index) || index < 0) return;
+	return {
+		index,
+		moduleName: payload.slice(separator + 1)
+	};
+};
+var createExecutorSpawnExport = (capabilityId, functionPath) => `export const spawn = async (options = {}) => {
+  const source = await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [JSON.stringify(options ?? {})]);
+  return JSON.parse(source);
+};`;
+var createGenericFunctionExport = (exportName, capabilityId, functionPath) => `export const ${exportName} = async (...args) =>
+  await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, args);`;
+var createModuleSource = (rule) => {
+	const exportedFunctions = getExportedFunctions(rule.namespace, rule.rule.allow);
+	if (exportedFunctions.length === 0) throw new Error(`Muon capability import has no exact function exports: ${rule.moduleName}`);
+	return `const __muonCall = globalThis.__muon_plugin_call;
+if (typeof __muonCall !== "function") {
+  throw new Error("Muon plugin capability bridge is not available.");
+}
+
+${exportedFunctions.map(([exportName, functionPath]) => rule.namespace === "muon.executor" && exportName === "spawn" ? createExecutorSpawnExport(rule.id, functionPath) : createGenericFunctionExport(exportName, rule.id, functionPath)).join("\n\n")}
+`;
+};
+/**
+* Creates a capability virtual module resolver for a bundler adapter.
+*
+* @param root Bundler project root.
+* @param options Capability import options.
+*/
+var createMuonCapabilityModuleResolver = (root, options) => {
+	const rules = [...options?.imports ?? []];
+	for (const rule of rules) validateCapabilityRule(rule);
+	const runtimeEntries = rules.map((rule, index) => createRuleRuntimeEntry(rule, index));
+	const resolveRule = (source, importer) => {
+		const parsed = parseCapabilitySpecifier(source);
+		if (parsed === void 0) return;
+		if (!rules.some((rule) => hasNamespaceFunctionAllow(parsed.namespace, rule.allow))) return;
+		if (importer === void 0) throw new Error(`Muon capability import is not allowed without an importer: ${source}`);
+		const relativeImporter = toRootRelativeImporter(root, importer);
+		for (let index = 0; index < rules.length; index += 1) {
+			const rule = rules[index];
+			if (rule === void 0 || !matchesCapabilityRuleImporter(rule, root, importer) || !hasNamespaceFunctionAllow(parsed.namespace, rule.allow)) continue;
+			return {
+				index,
+				id: runtimeEntries[index]?.id ?? hashCapabilityRule(index, rule),
+				rule,
+				namespace: parsed.namespace,
+				moduleName: parsed.moduleName
+			};
+		}
+		throw new Error(`Muon capability import is not allowed: ${source} from ${relativeImporter}`);
+	};
+	return {
+		resolveId: (source, importer) => {
+			const rule = resolveRule(source, importer);
+			return rule === void 0 ? void 0 : { id: createModuleVirtualId(rule) };
+		},
+		load: (id) => {
+			const parsed = parseModuleVirtualId(id);
+			if (parsed === void 0) return;
+			const source = parseCapabilitySpecifier(parsed.moduleName);
+			const rule = rules[parsed.index];
+			const runtimeEntry = runtimeEntries[parsed.index];
+			if (source === void 0 || rule === void 0 || runtimeEntry === void 0) return;
+			return createModuleSource({
+				index: parsed.index,
+				id: runtimeEntry.id,
+				rule,
+				namespace: source.namespace,
+				moduleName: source.moduleName
+			});
+		},
+		getRuntimePluginConfig: () => ({
+			mode: "validate",
+			capabilities: runtimeEntries
+		})
+	};
+};
+//#endregion
+//#region src/plugin-access.ts
+var import_dist = require_vite_internals.require_dist();
+var defaultConfigFileNames = [
+	"muon.json5",
+	"muon.jsonc",
+	"muon.json"
+];
+var defaultPluginPages = ["asset://main/**"];
+var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+var isSha1HexString = (value) => value.length === 40 && /^[0-9a-fA-F]+$/.test(value);
+var isHexByteString = (value) => value.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(value);
+var getErrorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
+var fileExists = async (path) => {
+	try {
+		await (0, node_fs_promises.access)(path, node_fs.constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var resolveMuonConfigPath = async (root, configPath) => {
+	if (configPath !== void 0) {
+		const resolvedPath = (0, node_path.resolve)(root, configPath);
+		if (await fileExists(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;
+	}
+};
+var readJsonObjectFile = async (path, label) => {
+	let content;
+	try {
+		content = await (0, node_fs_promises.readFile)(path, "utf8");
+	} catch (error) {
+		throw new Error(`${label} could not be read: ${path}: ${getErrorMessage$1(error)}`);
+	}
+	let parsed;
+	try {
+		parsed = (0, import_dist.parse)(content);
+	} catch (error) {
+		throw new Error(`${label} could not be parsed: ${path}: ${getErrorMessage$1(error)}`);
+	}
+	if (!isJsonObject(parsed)) throw new Error(`${label} must contain a JSON object: ${path}`);
+	return parsed;
+};
+var readOptionalStringArray = (object, key, configPath) => {
+	const value = object[key];
+	if (value === void 0) return;
+	if (!isStringArray(value)) throw new Error(`muon.json ${configPath} must be an array of strings.`);
+	return value;
+};
+var readPluginAccessImportOptions = (value, configPath) => {
+	if (!isJsonObject(value)) throw new Error(`muon.json ${configPath} must be an object.`);
+	const sources = readOptionalStringArray(value, "sources", `${configPath}.sources`);
+	const packages = readOptionalStringArray(value, "packages", `${configPath}.packages`);
+	const allow = readOptionalStringArray(value, "allow", `${configPath}.allow`);
+	const options = {};
+	if (sources !== void 0) options.sources = sources;
+	if (packages !== void 0) options.packages = packages;
+	if (allow !== void 0) options.allow = allow;
+	return options;
+};
+var readPluginAccessEntryOptions = (value, index) => {
+	const configPath = `plugin.plugins[${index}]`;
+	if (!isJsonObject(value)) throw new Error(`muon.json ${configPath} must be an object.`);
+	if (typeof value.name !== "string") throw new Error(`muon.json ${configPath}.name must be a string.`);
+	if (value.signature !== void 0) {
+		if (typeof value.signature !== "string") throw new Error(`muon.json ${configPath}.signature must be a string.`);
+		if (!isSha1HexString(value.signature)) throw new Error(`muon.json ${configPath}.signature must be a 40-character SHA-1 hex string.`);
+	}
+	if (value.salt !== void 0) {
+		if (typeof value.salt !== "string") throw new Error(`muon.json ${configPath}.salt must be a string.`);
+		if (!isHexByteString(value.salt)) throw new Error(`muon.json ${configPath}.salt must be a hexadecimal byte string.`);
+	}
+	const allow = readOptionalStringArray(value, "allow", `${configPath}.allow`);
+	const rawImports = value.imports;
+	if (rawImports !== void 0 && !Array.isArray(rawImports)) throw new Error(`muon.json ${configPath}.imports must be an array.`);
+	const imports = rawImports === void 0 ? void 0 : rawImports.map((entry, importIndex) => readPluginAccessImportOptions(entry, `${configPath}.imports[${importIndex}]`));
+	const options = { name: value.name };
+	if (value.signature !== void 0) options.signature = value.signature;
+	if (value.salt !== void 0) options.salt = value.salt;
+	if (allow !== void 0) options.allow = allow;
+	if (imports !== void 0) options.imports = imports;
+	return options;
+};
+var readPluginAccessOptions = (config) => {
+	const browser = config.browser;
+	if (isJsonObject(browser) && browser.plugin !== void 0) throw new Error("muon.json browser.plugin is no longer supported; use plugin.mode and plugin.pages instead.");
+	const plugin = config.plugin;
+	if (plugin === void 0) return {};
+	if (!isJsonObject(plugin)) throw new Error("muon.json plugin must be an object.");
+	const options = {};
+	if (plugin.path !== void 0) {
+		if (typeof plugin.path !== "string") throw new Error("muon.json plugin.path must be a string.");
+		if (plugin.path.length === 0) throw new Error("muon.json plugin.path must not be empty.");
+		options.path = plugin.path;
+	}
+	if (plugin.mode !== void 0) {
+		if (typeof plugin.mode !== "string") throw new Error("muon.json plugin.mode must be a string.");
+		if (plugin.mode.length === 0) throw new Error("muon.json plugin.mode must not be empty.");
+		if (plugin.mode !== "simple" && plugin.mode !== "validate") throw new Error("muon.json plugin.mode has unknown value.");
+		options.mode = plugin.mode;
+	}
+	const pages = readOptionalStringArray(plugin, "pages", "plugin.pages");
+	if (pages !== void 0) options.pages = pages;
+	const rawPlugins = plugin.plugins;
+	if (rawPlugins !== void 0) {
+		if (!Array.isArray(rawPlugins)) throw new Error("muon.json plugin.plugins must be an array.");
+		options.plugins = rawPlugins.map((entry, index) => readPluginAccessEntryOptions(entry, index));
+	}
+	return options;
+};
+var hasImportSourceSelector = (entry) => entry.sources !== void 0 && entry.sources.length > 0 || entry.packages !== void 0 && entry.packages.length > 0;
+var validatePluginAccessOptions = (resolved) => {
+	for (const [pluginIndex, plugin] of resolved.plugins.entries()) {
+		const pluginPath = `plugin.plugins[${pluginIndex}]`;
+		if (plugin.name === "internal" && plugin.signature !== void 0) throw new Error(`muon.json ${pluginPath}.signature is not supported for internal plugins.`);
+		if (plugin.name === "internal" && plugin.salt !== void 0) throw new Error(`muon.json ${pluginPath}.salt is not supported for internal plugins.`);
+		if (plugin.signature !== void 0 && plugin.salt === void 0) throw new Error(`muon.json ${pluginPath}.signature requires ${pluginPath}.salt.`);
+		if (resolved.mode === "validate") {
+			if (plugin.allow !== void 0) throw new Error(`muon.json ${pluginPath}.allow is only supported in simple mode; use ${pluginPath}.imports[].allow in validate mode.`);
+			if (plugin.imports === void 0) throw new Error(`muon.json ${pluginPath}.imports is required in validate mode.`);
+			if (plugin.imports.length === 0) throw new Error(`muon.json ${pluginPath}.imports must not be empty in validate mode.`);
+			for (const [importIndex, entry] of plugin.imports.entries()) {
+				const importPath = `${pluginPath}.imports[${importIndex}]`;
+				if (!hasImportSourceSelector(entry)) throw new Error(`muon.json ${importPath} requires sources or packages.`);
+				if (entry.allow === void 0) throw new Error(`muon.json ${importPath}.allow is required in validate mode.`);
+				if (entry.allow.length === 0) throw new Error(`muon.json ${importPath}.allow must not be empty in validate mode.`);
+			}
+			continue;
+		}
+		if (plugin.allow === void 0) throw new Error(`muon.json ${pluginPath}.allow is required in simple mode.`);
+		if (plugin.imports !== void 0) throw new Error(`muon.json ${pluginPath}.imports is only supported in validate mode.`);
+	}
+	return resolved;
+};
+var getValidateImportAllow = (entry, pluginIndex, importIndex) => {
+	if (entry.allow === void 0 || entry.allow.length === 0) throw new Error(`muon.json plugin.plugins[${pluginIndex}].imports[${importIndex}].allow is required in validate mode.`);
+	return entry.allow;
+};
+var getSimplePluginAllow = (plugin, pluginIndex) => {
+	if (plugin.allow === void 0) throw new Error(`muon.json plugin.plugins[${pluginIndex}].allow is required in simple mode.`);
+	return plugin.allow;
+};
+var toCapabilityImports = (plugins) => plugins.flatMap((plugin, pluginIndex) => (plugin.imports ?? []).map((entry, importIndex) => {
+	if (!hasImportSourceSelector(entry)) throw new Error(`muon.json plugin.plugins[${pluginIndex}].imports[${importIndex}] requires sources or packages.`);
+	const rule = {
+		allow: getValidateImportAllow(entry, pluginIndex, importIndex),
+		pluginName: plugin.name
+	};
+	if (entry.sources !== void 0) rule.sources = entry.sources;
+	if (entry.packages !== void 0) rule.packages = entry.packages;
+	return rule;
+}));
+var toValidateRuntimePluginEntries = (plugins) => plugins.map((plugin, pluginIndex) => {
+	const allow = [];
+	const seenAllow = /* @__PURE__ */ new Set();
+	for (const [importIndex, entry] of (plugin.imports ?? []).entries()) for (const functionPath of getValidateImportAllow(entry, pluginIndex, importIndex)) if (!seenAllow.has(functionPath)) {
+		seenAllow.add(functionPath);
+		allow.push(functionPath);
+	}
+	return {
+		name: plugin.name,
+		...plugin.signature === void 0 ? {} : { signature: plugin.signature },
+		...plugin.salt === void 0 ? {} : { salt: plugin.salt },
+		allow
+	};
+});
+var toSimpleRuntimePluginEntries = (plugins) => plugins.map((plugin, pluginIndex) => ({
+	name: plugin.name,
+	...plugin.signature === void 0 ? {} : { signature: plugin.signature },
+	...plugin.salt === void 0 ? {} : { salt: plugin.salt },
+	allow: [...getSimplePluginAllow(plugin, pluginIndex)]
+}));
+var shouldOverlayRuntimePlugins = (resolved, override) => override !== false && (override?.plugins !== void 0 || resolved.mode === "validate" && resolved.plugins.length > 0);
+var toRuntimePluginEntries = (resolved) => resolved.mode === "validate" ? toValidateRuntimePluginEntries(resolved.plugins) : toSimpleRuntimePluginEntries(resolved.plugins);
+var mergePluginAccessOptions = (base, override) => ({
+	...override?.path === void 0 ? {} : { path: override.path },
+	mode: override?.mode ?? base.mode ?? "validate",
+	pages: override?.pages ?? base.pages ?? defaultPluginPages,
+	plugins: override?.plugins ?? base.plugins ?? []
+});
+var createRuntimeOverlay = (root, resolved, override) => {
+	if (override === false) return {};
+	const path = override?.path !== void 0 ? (0, node_path.resolve)(root, override.path) : void 0;
+	const plugins = shouldOverlayRuntimePlugins(resolved, override) ? toRuntimePluginEntries(resolved) : void 0;
+	return {
+		pages: resolved.pages,
+		...path === void 0 ? {} : { path },
+		...plugins === void 0 ? {} : { plugins }
+	};
+};
+/**
+* Resolves public plugin access config from muon.json and Vite overrides.
+*
+* @param input Resolution inputs.
+* @returns Effective plugin access config for bundler integrations.
+*/
+var resolveMuonPluginAccessOptions = async ({ root, configPath, pluginAccess, onConfigReadError }) => {
+	const resolvedConfigPath = await resolveMuonConfigPath(root, configPath);
+	let base = {};
+	if (resolvedConfigPath !== void 0) try {
+		base = readPluginAccessOptions(await readJsonObjectFile(resolvedConfigPath, "Muon config file"));
+	} catch (error) {
+		if (onConfigReadError === void 0) throw error;
+		onConfigReadError(error);
+	}
+	if (pluginAccess === false) {
+		const resolved = validatePluginAccessOptions(mergePluginAccessOptions(base, { mode: "simple" }));
+		return {
+			mode: "simple",
+			pages: resolved.pages,
+			capabilityOptions: { imports: [] },
+			runtimeOverlay: createRuntimeOverlay(root, resolved, pluginAccess)
+		};
+	}
+	const resolved = validatePluginAccessOptions(mergePluginAccessOptions(base, pluginAccess));
+	const capabilityOptions = { imports: resolved.mode === "validate" ? toCapabilityImports(resolved.plugins) : [] };
+	return {
+		mode: resolved.mode,
+		pages: resolved.pages,
+		capabilityOptions,
+		runtimeOverlay: createRuntimeOverlay(root, resolved, pluginAccess)
+	};
+};
+//#endregion
 //#region src/vite.ts
-var suppressViteMuonBuildEnvironmentKey = "MUON_SUPPRESS_VITE_MUON_BUILD";
+var getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 /**
 * Creates a Vite plugin that launches Muon during Vite dev startup.
 *
 * @param options Muon plugin options used for development startup and build.
 * @returns Vite plugin instance.
+* @defaultValue `options` defaults to `{}`.
 */
 var muon = (options = {}) => {
 	let resolvedConfig = void 0;
-	return require_vite_options.attachMuonVitePluginOptions({
+	let capabilityResolver = void 0;
+	let resolvedPluginAccess = void 0;
+	return require_vite_internals.attachMuonVitePluginOptions({
 		name: "muon",
 		config: (config) => {
 			if (config.server?.watch === null) return null;
 			return { server: { watch: createMuonWatchOptions(config.server?.watch) } };
 		},
-		configResolved: (config) => {
+		configResolved: async (config) => {
 			resolvedConfig = config;
+			resolvedPluginAccess = await resolveMuonPluginAccessOptions({
+				root: config.root,
+				configPath: resolveMuonConfigPathForViteCommand(config, options),
+				pluginAccess: options.pluginAccess,
+				...config.command === "serve" ? { onConfigReadError: (error) => {
+					config.logger.warn(`Muon project config will be ignored because it could not be read or parsed: ${getErrorMessage(error)}`);
+				} } : {}
+			});
+			capabilityResolver = resolvedPluginAccess.mode === "validate" ? createMuonCapabilityModuleResolver(config.root, resolvedPluginAccess.capabilityOptions) : void 0;
 		},
+		resolveId: (source, importer) => capabilityResolver?.resolveId(source, importer)?.id,
+		load: (id) => capabilityResolver?.load(id),
 		configureServer: async (server) => {
-			await require_vite_options.startMuonViteBrowserBridge({
+			await require_vite_internals.startMuonViteBrowserBridge({
 				server,
 				pluginOptions: options,
+				getRuntimePluginConfig: () => resolveMuonRuntimePluginConfig(capabilityResolver, resolvedPluginAccess),
 				platform: process.platform,
 				architecture: process.arch,
 				environment: process.env
@@ -39,10 +463,10 @@ var muon = (options = {}) => {
 		},
 		closeBundle: async () => {
 			if (resolvedConfig === void 0 || resolvedConfig.command !== "build") return;
-			if (process.env[suppressViteMuonBuildEnvironmentKey] === "1") return;
+			if (process.env["MUON_SUPPRESS_VITE_MUON_BUILD"] === "1") return;
 			if (options.build === false) return;
 			const buildOptions = typeof options.build === "object" ? options.build : {};
-			await require_vite_options.buildMuonApp(createMuonBuildOptions(resolvedConfig, buildOptions));
+			await require_vite_internals.buildMuonApp(createMuonBuildOptions(resolvedConfig, buildOptions, resolveMuonRuntimePluginConfig(capabilityResolver, resolvedPluginAccess)));
 		}
 	}, options);
 };
@@ -59,7 +483,7 @@ var createMuonWatchOptions = (watch) => ({
 	...watch ?? {},
 	ignored: mergeMuonWatchIgnored(watch?.ignored)
 });
-var createMuonBuildOptions = (config, buildOptions) => {
+var createMuonBuildOptions = (config, buildOptions, runtimePluginConfig) => {
 	const outDir = (0, node_path.isAbsolute)(config.build.outDir) ? config.build.outDir : (0, node_path.resolve)(config.root, config.build.outDir);
 	const options = {
 		root: config.root,
@@ -72,10 +496,28 @@ var createMuonBuildOptions = (config, buildOptions) => {
 	if (buildOptions.appId !== void 0) options.appId = buildOptions.appId;
 	if (buildOptions.outputRoot !== void 0) options.outputRoot = buildOptions.outputRoot;
 	if (buildOptions.configPath !== void 0) options.configPath = buildOptions.configPath;
+	if (buildOptions.iconPath !== void 0) options.iconPath = buildOptions.iconPath;
+	if (buildOptions.windowsResource !== void 0) options.windowsResource = buildOptions.windowsResource;
+	if (buildOptions.linuxDesktop !== void 0) options.linuxDesktop = buildOptions.linuxDesktop;
 	if (buildOptions.packageDirectory !== void 0) options.packageDirectory = buildOptions.packageDirectory;
 	if (buildOptions.assetSalt !== void 0) options.assetSalt = buildOptions.assetSalt;
+	options.runtimePluginConfig = runtimePluginConfig;
 	return options;
 };
+var resolveMuonConfigPathForViteCommand = (config, options) => {
+	if (config.command !== "build" || typeof options.build !== "object") return;
+	return options.build.configPath;
+};
+var resolveMuonRuntimePluginConfig = (capabilityResolver, pluginAccess) => pluginAccess?.mode === "simple" ? {
+	mode: "simple",
+	...pluginAccess.runtimeOverlay
+} : {
+	...capabilityResolver?.getRuntimePluginConfig() ?? {
+		mode: "validate",
+		capabilities: []
+	},
+	...pluginAccess?.runtimeOverlay ?? {}
+};
 //#endregion
 module.exports = muon;