muon-ui 0.26.0 → 0.26.47

package/dist/vite.cjs

@@ -1,1302 +1,21 @@
 /*!
 * name: muon-ui
-* version: 0.26.0
+* version: 0.26.47
 * 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: 4bceacb2bf609778560407d23f4cba0e36315098
+* git.commit.hash: 95dc2712686873c8a022483fd9abf18598019bd7
 */
-const require_vite_internals = require("./vite-internals-DseKep-X.cjs");
+const require_vite_internals = require("./vite-internals-CueaxMaY.cjs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
+let node_fs = require("node:fs");
 let node_url = require("node:url");
 let node_child_process = require("node:child_process");
-let node_fs = require("node:fs");
 let node_os = require("node:os");
-let node_crypto = require("node:crypto");
-let node_util = require("node:util");
-//#region src/capability.ts
-var virtualModulePrefix = "\0muon-capability:";
-var capabilityIdByteLength = 16;
-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 defaultMuonCapabilityFunctionPaths = [
-	"muon.browser.reload",
-	"muon.browser.hardReload",
-	"muon.browser.toggleFullscreen",
-	"muon.browser.enterFullscreen",
-	"muon.browser.exitFullscreen",
-	"muon.browser.zoomIn",
-	"muon.browser.zoomOut",
-	"muon.browser.resetZoom",
-	"muon.browser.show",
-	"muon.browser.hide",
-	"muon.browser.focus",
-	"muon.browser.blur",
-	"muon.browser.minimize",
-	"muon.browser.maximize",
-	"muon.browser.restore",
-	"muon.browser.setTitleBarVisibility",
-	"muon.browser.setTitleBarIcon",
-	"muon.browser.getWindowBounds",
-	"muon.browser.setWindowBounds",
-	"muon.browser.setContextMenuItems",
-	"muon.browser.clearContextMenuItems",
-	"muon.browser.createTray",
-	"muon.browser.setTrayMenu",
-	"muon.browser.setTrayIcon",
-	"muon.browser.setTrayTooltip",
-	"muon.browser.removeTray",
-	"muon.browser.close",
-	"muon.browser.shutdown",
-	"muon.browser.recycle",
-	"muon.environments.getVariables",
-	"muon.environments.getConfigValues",
-	"muon.environments.getCommandLine",
-	"muon.environments.getProcessId",
-	"muon.environments.getRuntimeInfo",
-	"muon.environments.getAutostart",
-	"muon.environments.setAutostart",
-	"muon.executor.spawn",
-	"muon.executor.loadLibrary",
-	"muon.fs.readFile",
-	"muon.fs.writeFile",
-	"muon.fs.readTextFile",
-	"muon.fs.writeTextFile",
-	"muon.fs.stat",
-	"muon.fs.lstat",
-	"muon.fs.exists",
-	"muon.fs.access",
-	"muon.fs.readdir",
-	"muon.fs.mkdir",
-	"muon.fs.rm",
-	"muon.fs.unlink",
-	"muon.fs.rmdir",
-	"muon.fs.rename",
-	"muon.fs.copyFile",
-	"muon.fs.appendFile",
-	"muon.fs.appendTextFile",
-	"muon.fs.truncate",
-	"muon.fs.realpath",
-	"muon.fs.readlink",
-	"muon.fs.symlink",
-	"muon.fs.watch",
-	"muon.fs.dialogs.selectFile",
-	"muon.fs.dialogs.selectFiles",
-	"muon.fs.dialogs.selectDirectory",
-	"muon.fs.dialogs.selectDirectories",
-	"muon.fs.dialogs.selectSaveFile",
-	"muon.launcher.getSettings",
-	"muon.launcher.setSettings",
-	"muon.launcher.triggerUpdate"
-];
-var normalizePath = (path) => (path.split("?")[0] ?? "").replaceAll("\\", "/");
-var createCapabilityId = (usedIds) => {
-	for (;;) {
-		const id = `cap-${(0, node_crypto.randomBytes)(capabilityIdByteLength).toString("hex")}`;
-		if (!usedIds.has(id)) {
-			usedIds.add(id);
-			return id;
-		}
-	}
-};
-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 containsGlob = (value) => value.includes("*");
-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, functionPaths) => {
-	const exportedFunctions = /* @__PURE__ */ new Map();
-	const addExport = (functionPath) => {
-		const exportName = getExactExportName(namespace, functionPath);
-		if (exportName !== void 0 && !exportedFunctions.has(exportName)) exportedFunctions.set(exportName, functionPath);
-	};
-	for (const entry of allow) {
-		if (!containsGlob(entry)) {
-			addExport(entry);
-			continue;
-		}
-		for (const functionPath of functionPaths) if (isGlobMatch(entry, functionPath, ".")) addExport(functionPath);
-	}
-	return Array.from(exportedFunctions.entries());
-};
-var createFunctionPathCatalog = (functionPaths) => {
-	const catalog = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const functionPath of [...defaultMuonCapabilityFunctionPaths, ...functionPaths ?? []]) if (!seen.has(functionPath)) {
-		seen.add(functionPath);
-		catalog.push(functionPath);
-	}
-	return catalog;
-};
-var createRuleRuntimeEntry = (rule, id) => ({
-	id,
-	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) => `const __muonExecutorActiveProcesses = new Set();
-const __muonExecutorEmptyBytes = new Uint8Array(0);
-const __muonExecutorOwnerCallback = () => {};
-const __muonExecutorAsyncDispose =
-  typeof Symbol === "function" && typeof Symbol.asyncDispose === "symbol"
-    ? Symbol.asyncDispose
-    : null;
-const __muonExecutorToBytes = (data) => {
-  if (typeof data === "string") {
-    return new TextEncoder().encode(data);
-  }
-  if (data instanceof ArrayBuffer) {
-    return new Uint8Array(data);
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  }
-  throw new TypeError("stdin data must be a string or BufferSource");
-};
-const __muonExecutorFromBase64 = (source) => {
-  const text = atob(source ?? "");
-  const bytes = new Uint8Array(text.length);
-  for (let index = 0; index < text.length; index += 1) {
-    bytes[index] = text.charCodeAt(index);
-  }
-  return bytes;
-};
-const __muonExecutorRpc = async (
-  request,
-  data = __muonExecutorEmptyBytes,
-  onStdout = null,
-  onStderr = null,
-) =>
-  JSON.parse(
-    await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [
-      JSON.stringify(request),
-      data,
-      0,
-      __muonExecutorOwnerCallback,
-      onStdout,
-      onStderr,
-    ]),
-  );
-const __muonExecutorDecodeWaitResult = (raw) => {
-  const result = {
-    processId: raw.processId,
-    exitCode: raw.exitCode,
-  };
-  if (Object.prototype.hasOwnProperty.call(raw, "stdoutBase64")) {
-    result.stdout = __muonExecutorFromBase64(raw.stdoutBase64);
-  }
-  if (Object.prototype.hasOwnProperty.call(raw, "stderrBase64")) {
-    result.stderr = __muonExecutorFromBase64(raw.stderrBase64);
-  }
-  return result;
-};
-const __muonExecutorReleaseActiveProcesses = async () => {
-  if (__muonExecutorActiveProcesses.size === 0) {
-    return;
-  }
-  for (const handle of Array.from(__muonExecutorActiveProcesses)) {
-    try {
-      await handle.release();
-    } catch {}
-  }
-};
-if (typeof globalThis.addEventListener === "function") {
-  for (const eventName of ["beforeunload", "pagehide", "unload"]) {
-    globalThis.addEventListener(eventName, __muonExecutorReleaseActiveProcesses);
-  }
-}
-export const spawn = async (options = {}) => {
-  const stdoutCallback =
-    typeof options.onStdout === "function"
-      ? (chunk) => options.onStdout(new Uint8Array(chunk))
-      : null;
-  const stderrCallback =
-    typeof options.onStderr === "function"
-      ? (chunk) => options.onStderr(new Uint8Array(chunk))
-      : null;
-  const start = await __muonExecutorRpc(
-    {
-      op: "start",
-      options: {
-        command: options.command,
-        args: options.args,
-        cwd: options.cwd,
-        env: options.env,
-        daemon: options.daemon,
-      },
-      captureStdout: stdoutCallback === null,
-      captureStderr: stderrCallback === null,
-    },
-    __muonExecutorEmptyBytes,
-    stdoutCallback,
-    stderrCallback,
-  );
-  const handleId = start.handleId;
-  let released = false;
-  let stdinClosing = false;
-  let waitPromise = null;
-  const release = async () => {
-    if (released) {
-      return;
-    }
-    released = true;
-    __muonExecutorActiveProcesses.delete(handle);
-    await __muonExecutorRpc({ op: "dispose", handleId });
-  };
-  const handle = {
-    processId: start.processId,
-    writeStdin: async (data) => {
-      if (released) {
-        throw new Error("executor process is released");
-      }
-      if (stdinClosing) {
-        throw new Error("stdin is closed");
-      }
-      await __muonExecutorRpc(
-        { op: "writeStdin", handleId },
-        __muonExecutorToBytes(data),
-      );
-    },
-    closeStdin: async () => {
-      if (released) {
-        throw new Error("executor process is released");
-      }
-      stdinClosing = true;
-      await __muonExecutorRpc({ op: "closeStdin", handleId });
-    },
-    wait: () => {
-      if (waitPromise !== null) {
-        return waitPromise;
-      }
-      waitPromise = (async () => {
-        try {
-          return __muonExecutorDecodeWaitResult(
-            await __muonExecutorRpc({ op: "wait", handleId }),
-          );
-        } finally {
-          if (!released) {
-            released = true;
-            __muonExecutorActiveProcesses.delete(handle);
-            try {
-              await __muonExecutorRpc({ op: "dispose", handleId });
-            } catch {}
-          }
-        }
-      })();
-      return waitPromise;
-    },
-    kill: async () => {
-      if (released) {
-        throw new Error("executor process is released");
-      }
-      await __muonExecutorRpc({ op: "kill", handleId });
-    },
-    release,
-  };
-  if (__muonExecutorAsyncDispose !== null) {
-    Object.defineProperty(handle, __muonExecutorAsyncDispose, {
-      configurable: false,
-      enumerable: false,
-      value: release,
-      writable: false,
-    });
-  }
-  Object.freeze(handle);
-  __muonExecutorActiveProcesses.add(handle);
-  return handle;
-};`;
-var createExecutorLoadLibraryExport = (capabilityId, functionPath) => `const __muonAdhocActiveLibraries = new Set();
-const __muonAdhocEmptyBytes = new Uint8Array(0);
-const __muonAdhocAsyncDispose =
-  typeof Symbol === "function" && typeof Symbol.asyncDispose === "symbol"
-    ? Symbol.asyncDispose
-    : null;
-const __muonAdhocPointerBrand =
-  typeof Symbol === "function" ? Symbol.for("muon.nativePointer") : "__muonNativePointer";
-const __muonAdhocType = (name) => Object.freeze({ name });
-const __muonAdhocTypes = Object.freeze({
-  voidType: __muonAdhocType("void"),
-  boolType: __muonAdhocType("bool"),
-  int8Type: __muonAdhocType("int8"),
-  uint8Type: __muonAdhocType("uint8"),
-  int16Type: __muonAdhocType("int16"),
-  uint16Type: __muonAdhocType("uint16"),
-  int32Type: __muonAdhocType("int32"),
-  uint32Type: __muonAdhocType("uint32"),
-  int64Type: __muonAdhocType("int64"),
-  uint64Type: __muonAdhocType("uint64"),
-  float32Type: __muonAdhocType("float32"),
-  float64Type: __muonAdhocType("float64"),
-  stringType: __muonAdhocType("string"),
-  pointerType: __muonAdhocType("pointer"),
-  bufferViewType: __muonAdhocType("bufferView"),
-  usizeType: __muonAdhocType("usize"),
-});
-const __muonAdhocToBytes = (data) => {
-  if (typeof data === "string") {
-    return new TextEncoder().encode(data);
-  }
-  if (data instanceof ArrayBuffer) {
-    return new Uint8Array(data);
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  }
-  throw new TypeError("bufferView argument must be a string or BufferSource");
-};
-const __muonAdhocFromBase64 = (source) => {
-  const text = atob(source ?? "");
-  const bytes = new Uint8Array(text.length);
-  for (let index = 0; index < text.length; index += 1) {
-    bytes[index] = text.charCodeAt(index);
-  }
-  return bytes;
-};
-const __muonAdhocCreatePointer = (value) => {
-  const text = String(value ?? "0");
-  const pointer = {
-    [__muonAdhocPointerBrand]: true,
-    value: text,
-    toString: () => text,
-    toJSON: () => text,
-  };
-  return Object.freeze(pointer);
-};
-const __muonAdhocNormalizeType = (type) => {
-  if (typeof type === "string") {
-    return { name: type };
-  }
-  if (type && typeof type.name === "string") {
-    return { name: type.name };
-  }
-  throw new TypeError("adhoc type descriptor is invalid");
-};
-const __muonAdhocNormalizeSignature = (signature) => {
-  if (!signature || !Array.isArray(signature.argTypes)) {
-    throw new TypeError("adhoc signature is invalid");
-  }
-  return {
-    argTypes: signature.argTypes.map(__muonAdhocNormalizeType),
-    returnType: __muonAdhocNormalizeType(signature.returnType),
-  };
-};
-const __muonAdhocEncodeInteger = (value) => {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value) || Math.trunc(value) !== value) {
-      throw new TypeError("integer argument must be finite");
-    }
-    return String(value);
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  throw new TypeError("integer argument must be a number, bigint, or string");
-};
-const __muonAdhocEncodePointer = (value) => {
-  if (value === null || value === undefined) {
-    return "0";
-  }
-  if (typeof value === "object" && value[__muonAdhocPointerBrand]) {
-    return value.value;
-  }
-  return __muonAdhocEncodeInteger(value);
-};
-const __muonAdhocEncodeCall = (signature, args) => {
-  if (args.length !== signature.argTypes.length) {
-    throw new TypeError("Invalid adhoc argument count");
-  }
-  const encoded = [];
-  const chunks = [];
-  const bufferViews = [];
-  let offset = 0;
-  for (let index = 0; index < args.length; index += 1) {
-    const name = signature.argTypes[index].name;
-    const value = args[index];
-    if (name === "int64" || name === "uint64" || name === "usize") {
-      encoded.push(__muonAdhocEncodeInteger(value));
-    } else if (name === "pointer") {
-      encoded.push(__muonAdhocEncodePointer(value));
-    } else if (name === "bufferView") {
-      const bytes = __muonAdhocToBytes(value);
-      chunks.push(bytes);
-      bufferViews.push({ argIndex: index, offset, size: bytes.byteLength });
-      offset += bytes.byteLength;
-      encoded.push(null);
-    } else {
-      encoded.push(value);
-    }
-  }
-  const data = new Uint8Array(offset);
-  let writeOffset = 0;
-  for (const chunk of chunks) {
-    data.set(chunk, writeOffset);
-    writeOffset += chunk.byteLength;
-  }
-  return { args: encoded, bufferViews, data };
-};
-const __muonAdhocDecodeResult = (signature, raw) => {
-  const name = signature.returnType.name;
-  if (name === "void") {
-    return undefined;
-  }
-  if (name === "pointer") {
-    return __muonAdhocCreatePointer(raw.pointer);
-  }
-  if (name === "int64" || name === "uint64" || name === "usize") {
-    return BigInt(raw.value);
-  }
-  if (name === "bufferView") {
-    return __muonAdhocFromBase64(raw.base64);
-  }
-  return raw.value;
-};
-const __muonAdhocRpc = async (request, data = __muonAdhocEmptyBytes) =>
-  JSON.parse(
-    await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [
-      JSON.stringify(request),
-      data,
-      0,
-    ]),
-  );
-const __muonAdhocReleaseActiveLibraries = async () => {
-  if (__muonAdhocActiveLibraries.size === 0) {
-    return;
-  }
-  for (const handle of Array.from(__muonAdhocActiveLibraries)) {
-    try {
-      await handle.release();
-    } catch {}
-  }
-};
-if (typeof globalThis.addEventListener === "function") {
-  for (const eventName of ["beforeunload", "pagehide", "unload"]) {
-    globalThis.addEventListener(eventName, __muonAdhocReleaseActiveLibraries);
-  }
-}
-export const voidType = __muonAdhocTypes.voidType;
-export const boolType = __muonAdhocTypes.boolType;
-export const int8Type = __muonAdhocTypes.int8Type;
-export const uint8Type = __muonAdhocTypes.uint8Type;
-export const int16Type = __muonAdhocTypes.int16Type;
-export const uint16Type = __muonAdhocTypes.uint16Type;
-export const int32Type = __muonAdhocTypes.int32Type;
-export const uint32Type = __muonAdhocTypes.uint32Type;
-export const int64Type = __muonAdhocTypes.int64Type;
-export const uint64Type = __muonAdhocTypes.uint64Type;
-export const float32Type = __muonAdhocTypes.float32Type;
-export const float64Type = __muonAdhocTypes.float64Type;
-export const stringType = __muonAdhocTypes.stringType;
-export const pointerType = __muonAdhocTypes.pointerType;
-export const bufferViewType = __muonAdhocTypes.bufferViewType;
-export const usizeType = __muonAdhocTypes.usizeType;
-export const loadLibrary = async (path) => {
-  const start = await __muonAdhocRpc({ op: "load", path });
-  const libraryId = start.libraryId;
-  let released = false;
-  const release = async () => {
-    if (released) {
-      return;
-    }
-    released = true;
-    __muonAdhocActiveLibraries.delete(handle);
-    await __muonAdhocRpc({ op: "release", libraryId });
-  };
-  const handle = {
-    getFunction: async (name, signature) => {
-      if (released) {
-        throw new Error("adhoc library is released");
-      }
-      const normalizedSignature = __muonAdhocNormalizeSignature(signature);
-      const loaded = await __muonAdhocRpc({
-        op: "getFunction",
-        libraryId,
-        name,
-        signature: normalizedSignature,
-      });
-      const functionId = loaded.functionId;
-      return async (...args) => {
-        if (released) {
-          throw new Error("adhoc library is released");
-        }
-        const encoded = __muonAdhocEncodeCall(normalizedSignature, args);
-        const raw = await __muonAdhocRpc(
-          {
-            op: "call",
-            libraryId,
-            functionId,
-            args: encoded.args,
-            bufferViews: encoded.bufferViews,
-          },
-          encoded.data,
-        );
-        return __muonAdhocDecodeResult(normalizedSignature, raw);
-      };
-    },
-    release,
-  };
-  if (__muonAdhocAsyncDispose !== null) {
-    Object.defineProperty(handle, __muonAdhocAsyncDispose, {
-      configurable: false,
-      enumerable: false,
-      value: release,
-      writable: false,
-    });
-  }
-  Object.freeze(handle);
-  __muonAdhocActiveLibraries.add(handle);
-  return handle;
-};`;
-var createBrowserContextMenuHelpers = () => `const __muonBrowserContextMenuEventName = "muon-browser-context-menu-command";
-const __muonBrowserContextMenuWhenKeys = [
-  "editable",
-  "selection",
-  "link",
-  "image",
-  "canCopy",
-  "canPaste",
-];
-let __muonBrowserContextMenuToken = "";
-let __muonBrowserContextMenuHandler = undefined;
-let __muonBrowserContextMenuListening = false;
-const __muonCreateBrowserContextMenuToken = () => {
-  const crypto = globalThis.crypto;
-  if (
-    crypto &&
-    typeof crypto.getRandomValues === "function" &&
-    typeof globalThis.Uint32Array === "function"
-  ) {
-    const values = new globalThis.Uint32Array(4);
-    crypto.getRandomValues(values);
-    return Array.from(values, (value) => value.toString(16).padStart(8, "0")).join("");
-  }
-  return \`\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2)}\`;
-};
-const __muonEnsureBrowserContextMenuListener = () => {
-  if (
-    __muonBrowserContextMenuListening ||
-    typeof globalThis.addEventListener !== "function"
-  ) {
-    return;
-  }
-  globalThis.addEventListener(__muonBrowserContextMenuEventName, (event) => {
-    const detail = event && event.detail;
-    if (
-      typeof detail !== "object" ||
-      detail === null ||
-      detail.token !== __muonBrowserContextMenuToken ||
-      typeof __muonBrowserContextMenuHandler !== "function"
-    ) {
-      return;
-    }
-    __muonBrowserContextMenuHandler(detail);
-  });
-  __muonBrowserContextMenuListening = true;
-};
-const __muonNormalizeBrowserContextMenuPlacement = (placement) => {
-  if (placement === undefined) {
-    return undefined;
-  }
-  if (placement === "start" || placement === "afterEdit" || placement === "end") {
-    return placement;
-  }
-  throw new TypeError("Invalid context menu placement");
-};
-const __muonNormalizeBrowserContextMenuWhen = (when) => {
-  if (when === undefined) {
-    return undefined;
-  }
-  if (typeof when !== "object" || when === null || Array.isArray(when)) {
-    throw new TypeError("Invalid context menu condition");
-  }
-  const normalized = {};
-  for (const key of __muonBrowserContextMenuWhenKeys) {
-    const value = when[key];
-    if (value === undefined) {
-      continue;
-    }
-    if (typeof value !== "boolean") {
-      throw new TypeError("Invalid context menu condition");
-    }
-    normalized[key] = value;
-  }
-  return normalized;
-};
-const __muonNormalizeBrowserContextMenuCommandId = (id) => {
-  if (
-    typeof id !== "string" ||
-    id === "" ||
-    /[\\u0000-\\u001f]/u.test(id) ||
-    id.startsWith("muon.") ||
-    id.startsWith("standard.")
-  ) {
-    throw new TypeError("Invalid context menu item id");
-  }
-  return id;
-};
-const __muonNormalizeBrowserContextMenuItem = (item) => {
-  if (typeof item !== "object" || item === null || Array.isArray(item)) {
-    throw new TypeError("Invalid context menu item");
-  }
-  const placement = __muonNormalizeBrowserContextMenuPlacement(item.placement);
-  const when = __muonNormalizeBrowserContextMenuWhen(item.when);
-  if (item.type === "separator") {
-    return {
-      type: "separator",
-      ...(placement === undefined ? {} : { placement }),
-      ...(when === undefined ? {} : { when }),
-    };
-  }
-  if (item.type !== undefined && item.type !== "item") {
-    throw new TypeError("Invalid context menu item type");
-  }
-  if (typeof item.label !== "string" || item.label === "") {
-    throw new TypeError("Invalid context menu item label");
-  }
-  if (item.enabled !== undefined && typeof item.enabled !== "boolean") {
-    throw new TypeError("Invalid context menu item enabled state");
-  }
-  return {
-    id: __muonNormalizeBrowserContextMenuCommandId(item.id),
-    label: item.label,
-    enabled: item.enabled === undefined ? true : item.enabled,
-    ...(placement === undefined ? {} : { placement }),
-    ...(when === undefined ? {} : { when }),
-  };
-};
-const __muonNormalizeBrowserContextMenuItems = (items) => {
-  if (!Array.isArray(items)) {
-    throw new TypeError("Invalid context menu items");
-  }
-  return items.map(__muonNormalizeBrowserContextMenuItem);
-};`;
-var createBrowserSetContextMenuItemsExport = (capabilityId, functionPath) => `export const setContextMenuItems = async (items, handler = undefined) => {
-  if (handler !== undefined && typeof handler !== "function") {
-    throw new TypeError("Invalid context menu handler");
-  }
-  const normalized = __muonNormalizeBrowserContextMenuItems(items);
-  const token = __muonCreateBrowserContextMenuToken();
-  await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [JSON.stringify(normalized), token]);
-  __muonBrowserContextMenuToken = token;
-  __muonBrowserContextMenuHandler = handler;
-  __muonEnsureBrowserContextMenuListener();
-};`;
-var createBrowserClearContextMenuItemsExport = (capabilityId, functionPath) => `export const clearContextMenuItems = async () => {
-  __muonBrowserContextMenuToken = "";
-  __muonBrowserContextMenuHandler = undefined;
-  await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, []);
-};`;
-var createBrowserTrayHelpers = () => `const __muonBrowserTrayEventName = "muon-browser-tray-event";
-const __muonBrowserTrayHandlers = new Map();
-let __muonBrowserTrayListening = false;
-const __muonCreateBrowserTrayToken = () => {
-  const crypto = globalThis.crypto;
-  if (
-    crypto &&
-    typeof crypto.getRandomValues === "function" &&
-    typeof globalThis.Uint32Array === "function"
-  ) {
-    const values = new globalThis.Uint32Array(4);
-    crypto.getRandomValues(values);
-    return Array.from(values, (value) => value.toString(16).padStart(8, "0")).join("");
-  }
-  return \`\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2)}\`;
-};
-const __muonEnsureBrowserTrayListener = () => {
-  if (
-    __muonBrowserTrayListening ||
-    typeof globalThis.addEventListener !== "function"
-  ) {
-    return;
-  }
-  globalThis.addEventListener(__muonBrowserTrayEventName, (event) => {
-    const detail = event && event.detail;
-    if (
-      typeof detail !== "object" ||
-      detail === null ||
-      typeof detail.trayId !== "string"
-    ) {
-      return;
-    }
-    const entry = __muonBrowserTrayHandlers.get(detail.trayId);
-    if (
-      entry === undefined ||
-      detail.token !== entry.token ||
-      typeof entry.handler !== "function"
-    ) {
-      return;
-    }
-    entry.handler(detail);
-  });
-  __muonBrowserTrayListening = true;
-};
-const __muonNormalizeBrowserTrayId = (id) => {
-  if (
-    typeof id !== "string" ||
-    id === "" ||
-    /[\\u0000-\\u001f]/u.test(id) ||
-    id.startsWith("muon.") ||
-    id.startsWith("standard.")
-  ) {
-    throw new TypeError("Invalid tray id");
-  }
-  return id;
-};
-const __muonNormalizeBrowserTrayMenuItem = (item) => {
-  if (typeof item !== "object" || item === null || Array.isArray(item)) {
-    throw new TypeError("Invalid tray menu item");
-  }
-  if (item.type === "separator") {
-    return { type: "separator" };
-  }
-  const type = item.type === undefined ? "item" : item.type;
-  if (type !== "item" && type !== "checkbox" && type !== "radio") {
-    throw new TypeError("Invalid tray menu item type");
-  }
-  if (typeof item.label !== "string" || item.label === "") {
-    throw new TypeError("Invalid tray menu item label");
-  }
-  if (item.enabled !== undefined && typeof item.enabled !== "boolean") {
-    throw new TypeError("Invalid tray menu item enabled state");
-  }
-  if (item.checked !== undefined && typeof item.checked !== "boolean") {
-    throw new TypeError("Invalid tray menu item checked state");
-  }
-  if (type === "item" && item.checked !== undefined) {
-    throw new TypeError("Invalid tray menu item checked state");
-  }
-  return {
-    ...(type === "item" ? {} : { type }),
-    id: __muonNormalizeBrowserTrayId(item.id),
-    label: item.label,
-    enabled: item.enabled === undefined ? true : item.enabled,
-    ...(item.checked === undefined ? {} : { checked: item.checked }),
-  };
-};
-const __muonNormalizeBrowserTrayMenuItems = (items) => {
-  if (!Array.isArray(items)) {
-    throw new TypeError("Invalid tray menu items");
-  }
-  return items.map(__muonNormalizeBrowserTrayMenuItem);
-};
-const __muonNormalizeBrowserTrayOptions = (options) => {
-  if (typeof options !== "object" || options === null || Array.isArray(options)) {
-    throw new TypeError("Invalid tray options");
-  }
-  const hasIcon = options.icon !== undefined;
-  if (hasIcon && (typeof options.icon !== "string" || options.icon === "")) {
-    throw new TypeError("Invalid tray icon");
-  }
-  if (options.tooltip !== undefined && options.tooltip !== null && typeof options.tooltip !== "string") {
-    throw new TypeError("Invalid tray tooltip");
-  }
-  return {
-    ...(options.id === undefined ? {} : { id: __muonNormalizeBrowserTrayId(options.id) }),
-    ...(hasIcon ? { icon: options.icon } : {}),
-    ...(options.tooltip === undefined || options.tooltip === null ? {} : { tooltip: options.tooltip }),
-    ...(options.menu === undefined ? {} : { menu: __muonNormalizeBrowserTrayMenuItems(options.menu) }),
-  };
-};`;
-var createBrowserCreateTrayExport = (capabilityId, functionPath) => `export const createTray = async (options, handler = undefined) => {
-  if (handler !== undefined && typeof handler !== "function") {
-    throw new TypeError("Invalid tray handler");
-  }
-  const normalized = __muonNormalizeBrowserTrayOptions(options);
-  const token = __muonCreateBrowserTrayToken();
-  const trayId = await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [JSON.stringify(normalized), token]);
-  __muonBrowserTrayHandlers.set(trayId, { token, handler });
-  __muonEnsureBrowserTrayListener();
-  return trayId;
-};`;
-var createBrowserSetTrayMenuExport = (capabilityId, functionPath) => `export const setTrayMenu = async (id, items, handler = undefined) => {
-  if (handler !== undefined && typeof handler !== "function") {
-    throw new TypeError("Invalid tray handler");
-  }
-  const trayId = __muonNormalizeBrowserTrayId(id);
-  const normalized = __muonNormalizeBrowserTrayMenuItems(items);
-  const token = __muonCreateBrowserTrayToken();
-  await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [trayId, JSON.stringify(normalized), token]);
-  __muonBrowserTrayHandlers.set(trayId, { token, handler });
-  __muonEnsureBrowserTrayListener();
-};`;
-var createBrowserSetTrayIconExport = (capabilityId, functionPath) => `export const setTrayIcon = async (id, iconPath) => {
-  const trayId = __muonNormalizeBrowserTrayId(id);
-  if (typeof iconPath !== "string" || iconPath === "") {
-    throw new TypeError("Invalid tray icon");
-  }
-  await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [trayId, iconPath]);
-};`;
-var createBrowserSetTrayTooltipExport = (capabilityId, functionPath) => `export const setTrayTooltip = async (id, tooltip) => {
-  const trayId = __muonNormalizeBrowserTrayId(id);
-  if (tooltip !== null && typeof tooltip !== "string") {
-    throw new TypeError("Invalid tray tooltip");
-  }
-  await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [trayId, tooltip === null ? "" : tooltip]);
-};`;
-var createBrowserRemoveTrayExport = (capabilityId, functionPath) => `export const removeTray = async (id) => {
-  const trayId = __muonNormalizeBrowserTrayId(id);
-  await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, [trayId]);
-  __muonBrowserTrayHandlers.delete(trayId);
-};`;
-var createGenericFunctionExport = (exportName, capabilityId, functionPath) => `export const ${exportName} = async (...args) =>
-  await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, args);`;
-var createEnvironmentsGetConfigValuesExport = (capabilityId, functionPath) => `export const getConfigValues = async () => JSON.parse(await __muonCall(${JSON.stringify(capabilityId)}, ${JSON.stringify(functionPath)}, []));`;
-var createModuleSource = (rule) => {
-	const exportedFunctions = getExportedFunctions(rule.namespace, rule.rule.allow, rule.functionPaths);
-	if (exportedFunctions.length === 0) {
-		const hasWildcardAllow = rule.rule.allow.some(containsGlob);
-		throw new Error(hasWildcardAllow ? `muon capability import has no matching function exports: ${rule.moduleName}` : `muon capability import has no exact function exports: ${rule.moduleName}`);
-	}
-	const usesBrowserContextMenuHelpers = exportedFunctions.some(([exportName]) => rule.namespace === "muon.browser" && (exportName === "setContextMenuItems" || exportName === "clearContextMenuItems"));
-	const usesBrowserTrayHelpers = exportedFunctions.some(([exportName]) => rule.namespace === "muon.browser" && (exportName === "createTray" || exportName === "setTrayMenu" || exportName === "setTrayIcon" || exportName === "setTrayTooltip" || exportName === "removeTray"));
-	const exports = exportedFunctions.map(([exportName, functionPath]) => {
-		if (rule.namespace === "muon.environments" && exportName === "getConfigValues") return createEnvironmentsGetConfigValuesExport(rule.id, functionPath);
-		if (rule.namespace === "muon.executor" && exportName === "spawn") return createExecutorSpawnExport(rule.id, functionPath);
-		if (rule.namespace === "muon.executor" && exportName === "loadLibrary") return createExecutorLoadLibraryExport(rule.id, functionPath);
-		if (rule.namespace === "muon.browser" && exportName === "setContextMenuItems") return createBrowserSetContextMenuItemsExport(rule.id, functionPath);
-		if (rule.namespace === "muon.browser" && exportName === "clearContextMenuItems") return createBrowserClearContextMenuItemsExport(rule.id, functionPath);
-		if (rule.namespace === "muon.browser" && exportName === "createTray") return createBrowserCreateTrayExport(rule.id, functionPath);
-		if (rule.namespace === "muon.browser" && exportName === "setTrayMenu") return createBrowserSetTrayMenuExport(rule.id, functionPath);
-		if (rule.namespace === "muon.browser" && exportName === "setTrayIcon") return createBrowserSetTrayIconExport(rule.id, functionPath);
-		if (rule.namespace === "muon.browser" && exportName === "setTrayTooltip") return createBrowserSetTrayTooltipExport(rule.id, functionPath);
-		if (rule.namespace === "muon.browser" && exportName === "removeTray") return createBrowserRemoveTrayExport(rule.id, functionPath);
-		return createGenericFunctionExport(exportName, rule.id, functionPath);
-	});
-	return `const __muonCall = globalThis.__muon_plugin_call;
-if (typeof __muonCall !== "function") {
-  throw new Error("muon plugin capability bridge is not available.");
-}
-
-${usesBrowserContextMenuHelpers ? `${createBrowserContextMenuHelpers()}\n\n` : ""}
-${usesBrowserTrayHelpers ? `${createBrowserTrayHelpers()}\n\n` : ""}
-${exports.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 ?? []];
-	const functionPaths = createFunctionPathCatalog(options?.functionPaths);
-	for (const rule of rules) validateCapabilityRule(rule);
-	const usedCapabilityIds = /* @__PURE__ */ new Set();
-	const runtimeEntries = rules.map((rule) => createRuleRuntimeEntry(rule, createCapabilityId(usedCapabilityIds)));
-	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];
-			const runtimeEntry = runtimeEntries[index];
-			if (rule === void 0 || runtimeEntry === void 0 || !matchesCapabilityRuleImporter(rule, root, importer) || !hasNamespaceFunctionAllow(parsed.namespace, rule.allow)) continue;
-			return {
-				index,
-				id: runtimeEntry.id,
-				rule,
-				namespace: parsed.namespace,
-				moduleName: parsed.moduleName,
-				functionPaths
-			};
-		}
-		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,
-				functionPaths
-			});
-		},
-		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 isSha256HexString = (value) => value.length === 64 && /^[0-9a-fA-F]+$/.test(value);
-var isHexByteString = (value) => value.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(value);
-var containsNul = (value) => value.includes("\0");
-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 readOptionalStringRecord = (object, key, configPath) => {
-	const value = object[key];
-	if (value === void 0) return;
-	if (!isJsonObject(value)) throw new Error(`muon.json ${configPath} must be an object.`);
-	const config = {};
-	for (const [entryKey, entryValue] of Object.entries(value)) {
-		if (entryKey.length === 0) throw new Error(`muon.json ${configPath} key must not be empty.`);
-		if (containsNul(entryKey)) throw new Error(`muon.json ${configPath} key must not contain NUL.`);
-		const valuePath = `${configPath}.${entryKey}`;
-		if (typeof entryValue !== "string") throw new Error(`muon.json ${valuePath} must be a string.`);
-		if (containsNul(entryValue)) throw new Error(`muon.json ${valuePath} must not contain NUL.`);
-		config[entryKey] = entryValue;
-	}
-	return config;
-};
-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 (!isSha256HexString(value.signature)) throw new Error(`muon.json ${configPath}.signature must be a 64-character SHA-256 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 config = readOptionalStringRecord(value, "config", `${configPath}.config`);
-	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 (config !== void 0) options.config = config;
-	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 validatePluginConfig = (rawConfig, configPath) => {
-	if (rawConfig === void 0) return;
-	if (!isJsonObject(rawConfig)) throw new Error(`muon.json ${configPath} must be an object.`);
-	for (const [entryKey, entryValue] of Object.entries(rawConfig)) {
-		if (entryKey.length === 0) throw new Error(`muon.json ${configPath} key must not be empty.`);
-		if (containsNul(entryKey)) throw new Error(`muon.json ${configPath} key must not contain NUL.`);
-		const valuePath = `${configPath}.${entryKey}`;
-		if (typeof entryValue !== "string") throw new Error(`muon.json ${valuePath} must be a string.`);
-		if (containsNul(entryValue)) throw new Error(`muon.json ${valuePath} must not contain NUL.`);
-	}
-};
-var validatePluginAccessOptions = (resolved) => {
-	for (const [pluginIndex, plugin] of resolved.plugins.entries()) {
-		const pluginPath = `plugin.plugins[${pluginIndex}]`;
-		const signature = plugin.signature;
-		if (signature !== void 0) {
-			if (typeof signature !== "string") throw new Error(`muon.json ${pluginPath}.signature must be a string.`);
-			if (!isSha256HexString(signature)) throw new Error(`muon.json ${pluginPath}.signature must be a 64-character SHA-256 hex string.`);
-		}
-		const salt = plugin.salt;
-		if (salt !== void 0) {
-			if (typeof salt !== "string") throw new Error(`muon.json ${pluginPath}.salt must be a string.`);
-			if (!isHexByteString(salt)) throw new Error(`muon.json ${pluginPath}.salt must be a hexadecimal byte string.`);
-		}
-		validatePluginConfig(plugin.config, `${pluginPath}.config`);
-		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 },
-		...plugin.config === void 0 ? {} : { config: plugin.config },
-		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 },
-	...plugin.config === void 0 ? {} : { config: plugin.config },
-	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 ?? base.path) === void 0 ? {} : { path: override?.path ?? base.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 }
-	};
-};
-var resolveInspectorPluginPath = (root, configPath, resolved, override) => {
-	if (override !== false && override?.path !== void 0) return (0, node_path.resolve)(root, override.path);
-	const basePath = configPath === void 0 ? root : (0, node_path.resolve)(configPath, "..");
-	return (0, node_path.resolve)(basePath, resolved.path ?? "./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),
-			pluginPath: resolveInspectorPluginPath(root, resolvedConfigPath, resolved, pluginAccess),
-			plugins: resolved.plugins
-		};
-	}
-	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),
-		pluginPath: resolveInspectorPluginPath(root, resolvedConfigPath, resolved, pluginAccess),
-		plugins: resolved.plugins
-	};
-};
-//#endregion
-//#region src/plugin-inspector.ts
-var execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
+//#region cef/plugin-inspector.ts
+var execFileAsync = (0, require("node:util").promisify)(node_child_process.execFile);
 var moduleDirectory = typeof __dirname === "string" ? __dirname : (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
 var getInspectorExecutableName = (platform) => platform === "win32" ? "muon-plugin-inspector.exe" : "muon-plugin-inspector";
 var canExecute = async (path) => {
@@ -1393,14 +112,51 @@ var collectMuonPluginFunctionPathsForAccess = async (pluginAccess, environment =
 	const wildcardPluginNames = new Set((pluginAccess.capabilityOptions.imports ?? []).filter((rule) => rule.pluginName !== void 0 && rule.pluginName !== "internal" && hasWildcardAllow(rule)).map((rule) => rule.pluginName));
 	if (wildcardPluginNames.size === 0) return [];
 	const plugins = pluginAccess.plugins.filter((plugin) => wildcardPluginNames.has(plugin.name));
-	return await collectMuonPluginFunctionPaths({
+	const catalogs = pluginAccess.nativeArtifacts ?? /* @__PURE__ */ new Map();
+	const producerPaths = plugins.flatMap((plugin) => catalogs.get(plugin.name)?.manifest.functions ?? []);
+	const inspected = await collectMuonPluginFunctionPaths({
 		pluginPath: pluginAccess.pluginPath,
-		plugins,
+		plugins: plugins.filter((plugin) => !catalogs.has(plugin.name)),
 		environment
 	});
+	return [...producerPaths, ...inspected];
 };
 //#endregion
-//#region src/vite.ts
+//#region android/plugin-catalog.ts
+/**
+* Resolves import permissions against producer catalogs for an Android Vite build.
+* @param root - Vite project root.
+* @param configPath - Application configuration override.
+* @param options - Android build options supplied by Vite.
+* @param access - Validated common plugin configuration.
+* @returns Concrete per-plugin import rules and their public function catalog.
+*/
+var collectMuonAndroidPluginAccess = async (root, configPath, options, access) => {
+	const path = await require_vite_internals.resolveMuonConfigPath(root, configPath);
+	const android = (path === void 0 ? {} : await require_vite_internals.readJsonObjectFile(path, "muon config file")).android ?? {};
+	const abis = options?.abis ?? android.abis ?? ["arm64-v8a", "x86_64"];
+	if (abis.length === 0 || abis.some((abi) => abi !== "arm64-v8a" && abi !== "x86_64")) throw new Error("android.abis must select arm64-v8a or x86_64.");
+	const libraries = options?.plugins ?? android.plugins ?? [];
+	const catalogs = await require_vite_internals.readAndroidPluginMetadata(libraries, abis, options?.plugins === void 0 && path !== void 0 ? (0, node_path.dirname)(path) : root, true);
+	const allCatalogs = new Map(catalogs);
+	for (const [name, artifact] of access.nativeArtifacts ?? []) {
+		if (allCatalogs.has(name)) throw new Error(`Duplicate Android plugin definition: ${name}`);
+		allCatalogs.set(name, artifact.manifest.functions);
+	}
+	return {
+		imports: access.plugins.flatMap((plugin) => {
+			const catalog = plugin.name === "internal" ? require_vite_internals.muonAndroidBuiltinFunctionPaths : allCatalogs.get(plugin.name);
+			if (catalog === void 0) throw new Error(`Android plugin ${plugin.name} requires a matching android.plugins metadata entry.`);
+			return (plugin.imports ?? []).map((rule) => ({
+				...rule,
+				allow: require_vite_internals.expandMuonAndroidFunctionAllows(rule.allow ?? [], catalog)
+			}));
+		}),
+		functionPaths: [...allCatalogs.values()].flat()
+	};
+};
+//#endregion
+//#region common/vite.ts
 var getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 var muonViteDisableArgument = "--no-muon";
 var muonNodeModuleSpecifier = "muon:node";
@@ -1429,9 +185,18 @@ var muon = (options = {}) => {
 	let resolvedPluginAccess = void 0;
 	let loadedCapabilityRuntimePluginConfig = void 0;
 	let nodeVirtualModuleEnabled = false;
-	const getRuntimePluginConfig = () => resolveMuonRuntimePluginConfig(capabilityResolver, resolvedPluginAccess);
+	let developmentNativeTarget;
+	const getRuntimePluginConfig = () => {
+		const policy = resolveMuonRuntimePluginConfig(capabilityResolver, resolvedPluginAccess);
+		const artifacts = resolvedPluginAccess?.nativeArtifacts;
+		return developmentNativeTarget === void 0 || artifacts === void 0 || artifacts.size === 0 ? policy : require_vite_internals.applyMuonNativePluginCatalogs(policy, artifacts, developmentNativeTarget, resolvedPluginAccess.runtimeOverlay.path);
+	};
 	const refreshPluginAccess = async (config) => {
-		resolvedPluginAccess = await resolveMuonPluginAccessOptions({
+		const targetOverride = process.env[require_vite_internals.muonBuildSequenceTargetsEnvironmentKey];
+		const normalizedTargets = (targetOverride === void 0 ? typeof options.build === "object" ? options.build.targets ?? [] : [] : JSON.parse(targetOverride)).flatMap((target) => target.split(",").map((part) => part.trim().toLowerCase()));
+		const backend = normalizedTargets.includes("android") ? "android" : "cef";
+		if (backend === "android" && normalizedTargets.some((target) => target !== "android")) throw new Error("Build Android and desktop Vite bundles separately.");
+		resolvedPluginAccess = await require_vite_internals.resolveMuonPluginAccessOptions({
 			root: config.root,
 			configPath: resolveMuonConfigPathForViteCommand(config, options),
 			pluginAccess: options.pluginAccess,
@@ -1439,9 +204,48 @@ var muon = (options = {}) => {
 				config.logger.warn(`muon project config will be ignored because it could not be read or parsed: ${getErrorMessage(error)}`);
 			} } : {}
 		});
-		const pluginFunctionPaths = await collectMuonPluginFunctionPathsForAccess(resolvedPluginAccess);
-		capabilityResolver = resolvedPluginAccess.mode === "validate" ? createMuonCapabilityModuleResolver(config.root, {
+		if (resolvedPluginAccess.plugins.some((plugin) => plugin.native !== void 0)) {
+			const build = typeof options.build === "object" ? options.build : {};
+			const sourceConfig = await require_vite_internals.readBuildConfig(config.root, resolveMuonConfigPathForViteCommand(config, options));
+			const android = {
+				...sourceConfig.config.android,
+				...build.android
+			};
+			const nativeTargets = backend === "android" ? (android.abis ?? ["arm64-v8a", "x86_64"]).map((abi) => `android-${abi}`) : config.command === "serve" ? [require_vite_internals.getDefaultMuonBuildTarget()] : require_vite_internals.resolveBuildTargets({
+				...build,
+				...normalizedTargets.length ? { targets: normalizedTargets } : {}
+			}).map((target) => target);
+			const sdkPath = android.sdkPath === void 0 ? void 0 : (0, node_path.resolve)(build.android?.sdkPath === void 0 ? sourceConfig.directory : config.root, android.sdkPath);
+			const artifacts = await require_vite_internals.resolveMuonNativePlugins({
+				root: config.root,
+				directory: resolvedPluginAccess.nativeDirectory ?? config.root,
+				plugins: resolvedPluginAccess.plugins,
+				targets: nativeTargets,
+				environment: process.env,
+				...sdkPath === void 0 ? {} : { androidSdkPath: sdkPath }
+			});
+			resolvedPluginAccess.nativeArtifacts = artifacts;
+			if (config.command === "serve" && backend === "cef") {
+				const target = nativeTargets[0];
+				developmentNativeTarget = target;
+				const directory = (0, node_path.join)(config.root, ".muon/plugins/runtime", target);
+				await require_vite_internals.stageMuonNativePlugins(artifacts, target, directory);
+				resolvedPluginAccess.runtimeOverlay = {
+					...resolvedPluginAccess.runtimeOverlay,
+					path: directory,
+					plugins: resolvedPluginAccess.runtimeOverlay.plugins ?? resolvedPluginAccess.plugins.map(({ native: _native, imports: _imports, ...entry }) => ({
+						...entry,
+						allow: entry.allow ?? []
+					}))
+				};
+			}
+		}
+		const androidAccess = backend === "android" && resolvedPluginAccess.mode === "validate" ? await collectMuonAndroidPluginAccess(config.root, resolveMuonConfigPathForViteCommand(config, options), typeof options.build === "object" ? options.build.android : void 0, resolvedPluginAccess) : void 0;
+		const pluginFunctionPaths = backend === "android" ? androidAccess?.functionPaths ?? [] : await collectMuonPluginFunctionPathsForAccess(resolvedPluginAccess);
+		capabilityResolver = resolvedPluginAccess.mode === "validate" ? require_vite_internals.createMuonCapabilityModuleResolver(config.root, {
 			...resolvedPluginAccess.capabilityOptions,
+			...androidAccess === void 0 ? {} : { imports: androidAccess.imports },
+			backend,
 			functionPaths: pluginFunctionPaths
 		}) : void 0;
 		loadedCapabilityRuntimePluginConfig = void 0;
@@ -1511,6 +315,7 @@ var muon = (options = {}) => {
 			const muonBuildOptions = createMuonBuildOptions(resolvedConfig, buildOptions, getRuntimePluginConfig());
 			const progressRenderer = require_vite_internals.createMuonProgressRenderer();
 			muonBuildOptions.progress = progressRenderer.report;
+			if (resolvedPluginAccess !== void 0) muonBuildOptions.nativePluginAccess = resolvedPluginAccess;
 			try {
 				await require_vite_internals.buildMuonApp(muonBuildOptions);
 			} finally {
@@ -1519,6 +324,7 @@ var muon = (options = {}) => {
 		}
 	}, options), {
 		getResolvedConfig: () => resolvedConfig,
+		getNativePluginAccess: () => resolvedPluginAccess,
 		getRuntimePluginConfig: () => resolvedConfig === void 0 ? void 0 : loadedCapabilityRuntimePluginConfig ?? getRuntimePluginConfig()
 	});
 };