@symbiosis-lab/moss-api 0.5.3 → 0.6.0

package/dist/index.mjs

@@ -541,6 +541,570 @@ async function executeBinary(options) {
 	};
 }
 
+//#endregion
+//#region src/utils/platform.ts
+/**
+* Platform detection utilities for Moss plugins
+*
+* Detects the current operating system and architecture to enable
+* platform-specific binary downloads and operations.
+*/
+let cachedPlatform = null;
+/**
+* Detect the current platform (OS and architecture)
+*
+* Uses system commands to detect the platform:
+* - On macOS/Linux: `uname -s` for OS, `uname -m` for architecture
+* - On Windows: Falls back to environment variables and defaults
+*
+* Results are cached after the first call.
+*
+* @returns Platform information including OS, architecture, and combined key
+* @throws Error if platform detection fails or platform is unsupported
+*
+* @example
+* ```typescript
+* const platform = await getPlatformInfo();
+* console.log(platform.platformKey); // "darwin-arm64"
+* ```
+*/
+async function getPlatformInfo() {
+	if (cachedPlatform) return cachedPlatform;
+	const os = await detectOS();
+	const arch = await detectArch(os);
+	const platformKey = `${os}-${arch}`;
+	const supportedPlatforms = [
+		"darwin-arm64",
+		"darwin-x64",
+		"linux-x64",
+		"windows-x64"
+	];
+	if (!supportedPlatforms.includes(platformKey)) throw new Error(`Unsupported platform: ${platformKey}. Supported platforms: ${supportedPlatforms.join(", ")}`);
+	cachedPlatform = {
+		os,
+		arch,
+		platformKey
+	};
+	return cachedPlatform;
+}
+/**
+* Clear the cached platform info
+*
+* Useful for testing or when platform detection needs to be re-run.
+*
+* @internal
+*/
+function clearPlatformCache() {
+	cachedPlatform = null;
+}
+/**
+* Detect the operating system
+*/
+async function detectOS() {
+	try {
+		const result = await executeBinary({
+			binaryPath: "uname",
+			args: ["-s"],
+			timeoutMs: 5e3
+		});
+		if (result.success) {
+			const osName = result.stdout.trim().toLowerCase();
+			if (osName === "darwin") return "darwin";
+			if (osName === "linux") return "linux";
+		}
+	} catch {}
+	try {
+		const result = await executeBinary({
+			binaryPath: "cmd",
+			args: ["/c", "ver"],
+			timeoutMs: 5e3
+		});
+		if (result.success && result.stdout.toLowerCase().includes("windows")) return "windows";
+	} catch {}
+	throw new Error("Unable to detect operating system. Supported systems: macOS (Darwin), Linux, Windows");
+}
+/**
+* Detect the CPU architecture
+*/
+async function detectArch(os) {
+	if (os === "windows") try {
+		const result = await executeBinary({
+			binaryPath: "cmd",
+			args: [
+				"/c",
+				"echo",
+				"%PROCESSOR_ARCHITECTURE%"
+			],
+			timeoutMs: 5e3
+		});
+		if (result.success) {
+			if (result.stdout.trim().toLowerCase() === "arm64") return "arm64";
+			return "x64";
+		}
+	} catch {
+		return "x64";
+	}
+	try {
+		const result = await executeBinary({
+			binaryPath: "uname",
+			args: ["-m"],
+			timeoutMs: 5e3
+		});
+		if (result.success) {
+			const machine = result.stdout.trim().toLowerCase();
+			if (machine === "arm64" || machine === "aarch64") return "arm64";
+			if (machine === "x86_64" || machine === "amd64") return "x64";
+			if (machine.includes("arm")) return "arm64";
+			return "x64";
+		}
+	} catch {}
+	return "x64";
+}
+
+//#endregion
+//#region src/utils/archive.ts
+/**
+* Archive extraction utilities for Moss plugins
+*
+* Provides functions to extract .tar.gz and .zip archives using
+* system commands (tar, unzip, PowerShell).
+*/
+/**
+* Extract an archive to a destination directory
+*
+* Uses system commands for extraction:
+* - .tar.gz: `tar -xzf` (macOS/Linux)
+* - .zip: `unzip` (macOS/Linux) or PowerShell `Expand-Archive` (Windows)
+*
+* @param options - Extraction options
+* @returns Extraction result
+*
+* @example
+* ```typescript
+* const result = await extractArchive({
+*   archivePath: "/path/to/hugo.tar.gz",
+*   destDir: "/path/to/extract/",
+* });
+*
+* if (!result.success) {
+*   console.error(`Extraction failed: ${result.error}`);
+* }
+* ```
+*/
+async function extractArchive(options) {
+	const { archivePath, destDir, timeoutMs = 6e4 } = options;
+	const format = options.format ?? detectFormat(archivePath);
+	if (!format) return {
+		success: false,
+		error: `Unable to detect archive format for: ${archivePath}. Supported formats: .tar.gz, .zip`
+	};
+	const platform = await getPlatformInfo();
+	try {
+		if (format === "tar.gz") return await extractTarGz(archivePath, destDir, timeoutMs);
+		else if (platform.os === "windows") return await extractZipWindows(archivePath, destDir, timeoutMs);
+		else return await extractZipUnix(archivePath, destDir, timeoutMs);
+	} catch (error$1) {
+		return {
+			success: false,
+			error: error$1 instanceof Error ? error$1.message : String(error$1)
+		};
+	}
+}
+/**
+* Make a file executable (Unix only)
+*
+* Runs `chmod +x` on the specified file. No-op on Windows.
+*
+* @param filePath - Absolute path to the file
+* @returns Whether the operation succeeded
+*
+* @example
+* ```typescript
+* await makeExecutable("/path/to/binary");
+* ```
+*/
+async function makeExecutable(filePath) {
+	if ((await getPlatformInfo()).os === "windows") return true;
+	try {
+		return (await executeBinary({
+			binaryPath: "chmod",
+			args: ["+x", filePath],
+			timeoutMs: 5e3
+		})).success;
+	} catch {
+		return false;
+	}
+}
+/**
+* Detect archive format from file extension
+*/
+function detectFormat(archivePath) {
+	const lowerPath = archivePath.toLowerCase();
+	if (lowerPath.endsWith(".tar.gz") || lowerPath.endsWith(".tgz")) return "tar.gz";
+	if (lowerPath.endsWith(".zip")) return "zip";
+	return null;
+}
+/**
+* Extract .tar.gz using tar command
+*/
+async function extractTarGz(archivePath, destDir, timeoutMs) {
+	const result = await executeBinary({
+		binaryPath: "tar",
+		args: [
+			"-xzf",
+			archivePath,
+			"-C",
+			destDir
+		],
+		timeoutMs
+	});
+	if (!result.success) return {
+		success: false,
+		error: result.stderr || `tar extraction failed with exit code ${result.exitCode}`
+	};
+	return { success: true };
+}
+/**
+* Extract .zip using unzip command (macOS/Linux)
+*/
+async function extractZipUnix(archivePath, destDir, timeoutMs) {
+	const result = await executeBinary({
+		binaryPath: "unzip",
+		args: [
+			"-o",
+			"-q",
+			archivePath,
+			"-d",
+			destDir
+		],
+		timeoutMs
+	});
+	if (!result.success) return {
+		success: false,
+		error: result.stderr || `unzip extraction failed with exit code ${result.exitCode}`
+	};
+	return { success: true };
+}
+/**
+* Extract .zip using PowerShell (Windows)
+*/
+async function extractZipWindows(archivePath, destDir, timeoutMs) {
+	const result = await executeBinary({
+		binaryPath: "powershell",
+		args: [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			`Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`
+		],
+		timeoutMs
+	});
+	if (!result.success) return {
+		success: false,
+		error: result.stderr || `PowerShell extraction failed with exit code ${result.exitCode}`
+	};
+	return { success: true };
+}
+
+//#endregion
+//#region src/utils/binary-resolver.ts
+/**
+* Binary resolver for Moss plugins
+*
+* Provides auto-detection and download of external CLI tools like Hugo.
+* Implements a 4-step resolution flow:
+*   1. Check configured path (from plugin config)
+*   2. Check system PATH
+*   3. Check plugin bin directory
+*   4. Download from GitHub releases (if enabled)
+*/
+/**
+* Error thrown during binary resolution
+*/
+var BinaryResolutionError = class extends Error {
+	constructor(message, phase, cause) {
+		super(message);
+		this.phase = phase;
+		this.cause = cause;
+		this.name = "BinaryResolutionError";
+	}
+};
+/**
+* Resolve a binary, downloading if necessary
+*
+* Resolution order:
+* 1. Configured path (from plugin config, e.g., hugo_path)
+* 2. System PATH (just the binary name)
+* 3. Plugin bin directory (.moss/plugins/{plugin}/bin/{name})
+* 4. Download from GitHub releases (if autoDownload is true)
+*
+* @param config - Binary configuration
+* @param options - Resolution options
+* @returns Resolution result with path and source
+* @throws BinaryResolutionError if binary cannot be resolved
+*
+* @example
+* ```typescript
+* const hugo = await resolveBinary(HUGO_CONFIG, {
+*   configuredPath: context.config.hugo_path,
+*   onProgress: (phase, msg) => reportProgress(phase, 0, 1, msg),
+* });
+*
+* await executeBinary({
+*   binaryPath: hugo.path,
+*   args: ["--version"],
+* });
+* ```
+*/
+async function resolveBinary(config, options = {}) {
+	const { configuredPath, autoDownload = true, onProgress } = options;
+	const progress = (phase, message) => {
+		onProgress?.(phase, message);
+	};
+	if (configuredPath) {
+		progress("detection", `Checking configured path: ${configuredPath}`);
+		const result = await checkBinary(configuredPath, config);
+		if (result) return {
+			path: configuredPath,
+			version: result.version,
+			source: "config"
+		};
+	}
+	progress("detection", `Checking system PATH for ${config.name}`);
+	const pathResult = await checkBinary(config.name, config);
+	if (pathResult) return {
+		path: config.name,
+		version: pathResult.version,
+		source: "path"
+	};
+	const pluginBinPath = await getPluginBinPath(config);
+	progress("detection", `Checking plugin storage: ${pluginBinPath}`);
+	if (await binaryExistsInPluginStorage(config)) {
+		const storedResult = await checkBinary(pluginBinPath, config);
+		if (storedResult) return {
+			path: pluginBinPath,
+			version: storedResult.version,
+			source: "plugin-storage"
+		};
+	}
+	if (!autoDownload) throw new BinaryResolutionError(`${config.name} not found. Please install it manually or set the path in plugin configuration.\n\nInstallation options:\n- Install via package manager (brew, apt, etc.)\n- Download from the official website\n- Set ${config.name}_path in .moss/config.toml`, "detection");
+	progress("download", `Downloading ${config.name}...`);
+	const downloadedPath = await downloadBinary(config, progress);
+	const downloadedResult = await checkBinary(downloadedPath, config);
+	if (!downloadedResult) throw new BinaryResolutionError(`Downloaded ${config.name} binary failed verification. The binary may be corrupted or incompatible with your system.`, "validation");
+	return {
+		path: downloadedPath,
+		version: downloadedResult.version,
+		source: "downloaded"
+	};
+}
+/**
+* Check if a binary exists and optionally extract its version
+*/
+async function checkBinary(binaryPath, config) {
+	try {
+		const [cmd, ...args] = parseCommand(config.versionCommand ?? `${config.name} version`, binaryPath, config.name);
+		const result = await executeBinary({
+			binaryPath: cmd,
+			args,
+			timeoutMs: 1e4
+		});
+		if (!result.success) return null;
+		let version;
+		if (config.versionPattern) {
+			const match = (result.stdout + result.stderr).match(config.versionPattern);
+			if (match && match[1]) version = match[1];
+		}
+		return { version };
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse a version command, replacing {name} with the binary path
+*/
+function parseCommand(template, binaryPath, name) {
+	const resolved = template.replace(/{name}/g, binaryPath);
+	if (resolved.startsWith(binaryPath)) return [binaryPath, ...resolved.slice(binaryPath.length).trim().split(/\s+/).filter(Boolean)];
+	return resolved.split(/\s+/).filter(Boolean);
+}
+/**
+* Get the full path to the binary in plugin storage
+*/
+async function getPluginBinPath(config) {
+	const ctx = getInternalContext();
+	const binaryName = getBinaryFilename(config, (await getPlatformInfo()).os === "windows");
+	return `${ctx.moss_dir}/plugins/${ctx.plugin_name}/bin/${binaryName}`;
+}
+/**
+* Get the binary filename (with .exe on Windows)
+*/
+function getBinaryFilename(config, isWindows) {
+	const baseName = config.binaryName ?? config.name;
+	return isWindows ? `${baseName}.exe` : baseName;
+}
+/**
+* Check if binary exists in plugin storage
+*/
+async function binaryExistsInPluginStorage(config) {
+	return pluginFileExists(`bin/${getBinaryFilename(config, (await getPlatformInfo()).os === "windows")}`);
+}
+/**
+* Download and extract binary from GitHub releases
+*/
+async function downloadBinary(config, progress) {
+	const platform = await getPlatformInfo();
+	const source = config.sources[platform.platformKey];
+	if (!source) throw new BinaryResolutionError(`No download source configured for platform: ${platform.platformKey}`, "download");
+	let version;
+	let downloadUrl;
+	if (source.github) {
+		progress("download", "Fetching latest release info from GitHub...");
+		version = (await getLatestRelease(source.github.owner, source.github.repo)).version;
+		const assetName = resolveAssetPattern(source.github.assetPattern, version, platform);
+		downloadUrl = `https://github.com/${source.github.owner}/${source.github.repo}/releases/download/v${version}/${assetName}`;
+	} else if (source.directUrl) throw new BinaryResolutionError("Direct URL downloads not yet implemented. Please use GitHub source.", "download");
+	else throw new BinaryResolutionError(`No download source configured for ${config.name}`, "download");
+	progress("download", `Downloading ${config.name} v${version}...`);
+	const ctx = getInternalContext();
+	const archiveFilename = downloadUrl.split("/").pop() ?? "archive";
+	const archivePath = `${ctx.moss_dir}/plugins/${ctx.plugin_name}/.tmp/${archiveFilename}`;
+	await downloadToPluginStorage(downloadUrl, `.tmp/${archiveFilename}`);
+	progress("extraction", "Extracting archive...");
+	const binDir = `${ctx.moss_dir}/plugins/${ctx.plugin_name}/bin`;
+	await writePluginFile("bin/.gitkeep", "");
+	const extractResult = await extractArchive({
+		archivePath,
+		destDir: binDir
+	});
+	if (!extractResult.success) throw new BinaryResolutionError(`Failed to extract archive: ${extractResult.error}`, "extraction");
+	const binaryPath = await getPluginBinPath(config);
+	await makeExecutable(binaryPath);
+	progress("complete", `${config.name} v${version} installed successfully`);
+	await cacheReleaseInfo(config.name, version);
+	return binaryPath;
+}
+/**
+* Fetch latest release info from GitHub API
+*/
+async function getLatestRelease(owner, repo) {
+	const cacheKey = `${owner}/${repo}`;
+	try {
+		const response = await fetchUrl(`https://api.github.com/repos/${owner}/${repo}/releases/latest`, { timeoutMs: 1e4 });
+		if (!response.ok) {
+			if (response.status === 403 || response.status === 429) {
+				const cached = await getCachedRelease(cacheKey);
+				if (cached) return cached;
+				throw new BinaryResolutionError("GitHub API rate limit exceeded. Please try again later or install the binary manually.", "download");
+			}
+			throw new BinaryResolutionError(`Failed to fetch release info: HTTP ${response.status}`, "download");
+		}
+		const tag = JSON.parse(response.text()).tag_name;
+		return {
+			version: tag.replace(/^v/, ""),
+			tag
+		};
+	} catch (error$1) {
+		if (error$1 instanceof BinaryResolutionError) throw error$1;
+		const cached = await getCachedRelease(cacheKey);
+		if (cached) return cached;
+		throw new BinaryResolutionError(`Failed to fetch release info: ${error$1 instanceof Error ? error$1.message : String(error$1)}`, "download", error$1 instanceof Error ? error$1 : void 0);
+	}
+}
+/**
+* Resolve asset pattern with actual values
+*/
+function resolveAssetPattern(pattern, version, platform) {
+	return pattern.replace(/{version}/g, version).replace(/{os}/g, platform.os).replace(/{arch}/g, {
+		x64: "amd64",
+		arm64: "arm64"
+	}[platform.arch] ?? platform.arch);
+}
+/**
+* Download a file to plugin storage
+*
+* Uses curl (macOS/Linux) or PowerShell (Windows) to download the file
+* directly to the target path, avoiding memory limitations of base64 encoding.
+*/
+async function downloadToPluginStorage(url, relativePath) {
+	const ctx = getInternalContext();
+	const platform = await getPlatformInfo();
+	const targetPath = `${ctx.moss_dir}/plugins/${ctx.plugin_name}/${relativePath}`;
+	const parentDir = targetPath.substring(0, targetPath.lastIndexOf("/"));
+	if (platform.os === "windows") {
+		await executeBinary({
+			binaryPath: "powershell",
+			args: [
+				"-NoProfile",
+				"-NonInteractive",
+				"-Command",
+				`New-Item -ItemType Directory -Force -Path '${parentDir}'`
+			],
+			timeoutMs: 5e3
+		});
+		const result = await executeBinary({
+			binaryPath: "powershell",
+			args: [
+				"-NoProfile",
+				"-NonInteractive",
+				"-Command",
+				`Invoke-WebRequest -Uri '${url}' -OutFile '${targetPath}'`
+			],
+			timeoutMs: 3e5
+		});
+		if (!result.success) throw new BinaryResolutionError(`Download failed: ${result.stderr || result.stdout}`, "download");
+	} else {
+		await executeBinary({
+			binaryPath: "mkdir",
+			args: ["-p", parentDir],
+			timeoutMs: 5e3
+		});
+		const result = await executeBinary({
+			binaryPath: "curl",
+			args: [
+				"-fsSL",
+				"--create-dirs",
+				"-o",
+				targetPath,
+				url
+			],
+			timeoutMs: 3e5
+		});
+		if (!result.success) throw new BinaryResolutionError(`Download failed: ${result.stderr || `curl exited with code ${result.exitCode}`}`, "download");
+	}
+}
+/**
+* Cache release info for fallback
+*/
+async function cacheReleaseInfo(name, version) {
+	try {
+		const cached = {
+			version,
+			tag: `v${version}`,
+			cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await writePluginFile(`cache/${name}-release.json`, JSON.stringify(cached, null, 2));
+	} catch {}
+}
+/**
+* Get cached release info
+*/
+async function getCachedRelease(cacheKey) {
+	try {
+		const name = cacheKey.split("/")[1];
+		if (!name) return null;
+		if (!await pluginFileExists(`cache/${name}-release.json`)) return null;
+		const content = await readPluginFile(`cache/${name}-release.json`);
+		const cached = JSON.parse(content);
+		return {
+			version: cached.version,
+			tag: cached.tag
+		};
+	} catch {
+		return null;
+	}
+}
+
 //#endregion
 //#region src/utils/cookies.ts
 /**
@@ -608,5 +1172,194 @@ async function setPluginCookie(cookies) {
 }
 
 //#endregion
-export { closeBrowser, downloadAsset, error, executeBinary, fetchUrl, fileExists, getMessageContext, getPluginCookie, getTauriCore, isTauriAvailable, listFiles, listPluginFiles, log, openBrowser, pluginFileExists, readFile, readPluginFile, reportComplete, reportError, reportProgress, sendMessage, setMessageContext, setPluginCookie, warn, writeFile, writePluginFile };
+//#region src/utils/window.ts
+/**
+* Window utilities for plugins
+* Enables plugins to show custom dialogs and UI elements
+*/
+/**
+* Show a plugin dialog and wait for user response
+*
+* The dialog can be an embedded HTML page (via data: URL) that communicates
+* back to the plugin via the submitDialogResult function.
+*
+* @param options - Dialog configuration
+* @returns Dialog result with submitted value or cancellation
+*
+* @example
+* ```typescript
+* const result = await showPluginDialog({
+*   url: createMyDialogUrl(),
+*   title: "Create Repository",
+*   width: 400,
+*   height: 300,
+* });
+*
+* if (result.type === "submitted") {
+*   console.log("User submitted:", result.value);
+* } else {
+*   console.log("User cancelled");
+* }
+* ```
+*/
+async function showPluginDialog(options) {
+	return await getTauriCore().invoke("show_plugin_dialog", {
+		url: options.url,
+		title: options.title,
+		width: options.width ?? 500,
+		height: options.height ?? 400,
+		timeoutMs: options.timeoutMs ?? 3e5
+	});
+}
+/**
+* Submit a result from within a plugin dialog
+*
+* This is called from inside the dialog HTML to send data back to the plugin.
+* The dialog will be closed automatically after submission.
+*
+* @param dialogId - The dialog ID (provided in the dialog's query string)
+* @param value - The value to submit
+* @returns Whether the submission was successful
+*
+* @example
+* ```typescript
+* // Inside dialog HTML:
+* const dialogId = new URLSearchParams(location.search).get('dialogId');
+* await submitDialogResult(dialogId, { repoName: 'my-repo' });
+* ```
+*/
+async function submitDialogResult(dialogId, value) {
+	return getTauriCore().invoke("submit_dialog_result", {
+		dialogId,
+		result: {
+			type: "submitted",
+			value
+		}
+	});
+}
+/**
+* Cancel a plugin dialog
+*
+* This is called from inside the dialog HTML to cancel without submitting.
+* The dialog will be closed automatically.
+*
+* @param dialogId - The dialog ID (provided in the dialog's query string)
+*
+* @example
+* ```typescript
+* // Inside dialog HTML:
+* const dialogId = new URLSearchParams(location.search).get('dialogId');
+* await cancelDialog(dialogId);
+* ```
+*/
+async function cancelDialog(dialogId) {
+	return getTauriCore().invoke("submit_dialog_result", {
+		dialogId,
+		result: { type: "cancelled" }
+	});
+}
+
+//#endregion
+//#region src/utils/events.ts
+/**
+* Get Tauri event API
+* @internal
+*/
+function getTauriEvent() {
+	const w = window;
+	if (!w.__TAURI__?.event) throw new Error("Tauri event API not available");
+	return w.__TAURI__.event;
+}
+/**
+* Check if Tauri event API is available
+*/
+function isEventApiAvailable() {
+	return !!window.__TAURI__?.event;
+}
+/**
+* Emit an event to other parts of the application
+*
+* @param event - Event name (e.g., "repo-created", "dialog-result")
+* @param payload - Data to send with the event
+*
+* @example
+* ```typescript
+* // From dialog:
+* await emitEvent("repo-name-validated", { name: "my-repo", available: true });
+*
+* // From plugin:
+* await emitEvent("deployment-started", { url: "https://github.com/..." });
+* ```
+*/
+async function emitEvent(event, payload) {
+	await getTauriEvent().emit(event, payload);
+}
+/**
+* Listen for events from other parts of the application
+*
+* @param event - Event name to listen for
+* @param handler - Function to call when event is received
+* @returns Cleanup function to stop listening
+*
+* @example
+* ```typescript
+* const unlisten = await onEvent<{ name: string; available: boolean }>(
+*   "repo-name-validated",
+*   (data) => {
+*     console.log(`Repo ${data.name} is ${data.available ? "available" : "taken"}`);
+*   }
+* );
+*
+* // Later, to stop listening:
+* unlisten();
+* ```
+*/
+async function onEvent(event, handler) {
+	return await getTauriEvent().listen(event, (e) => {
+		handler(e.payload);
+	});
+}
+/**
+* Wait for a single event occurrence
+*
+* @param event - Event name to wait for
+* @param timeoutMs - Maximum time to wait (default: 30000ms)
+* @returns Promise that resolves with the event payload
+* @throws Error if timeout is reached
+*
+* @example
+* ```typescript
+* try {
+*   const result = await waitForEvent<{ confirmed: boolean }>("user-confirmed", 10000);
+*   if (result.confirmed) {
+*     // proceed
+*   }
+* } catch (e) {
+*   console.log("User did not respond in time");
+* }
+* ```
+*/
+async function waitForEvent(event, timeoutMs = 3e4) {
+	return new Promise((resolve, reject) => {
+		let unlisten = null;
+		let timeoutId;
+		const cleanup = () => {
+			if (unlisten) unlisten();
+			clearTimeout(timeoutId);
+		};
+		timeoutId = setTimeout(() => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`Timeout waiting for event: ${event}`));
+		}, timeoutMs);
+		onEvent(event, (payload) => {
+			cleanup();
+			resolve(payload);
+		}).then((unlistenFn) => {
+			unlisten = unlistenFn;
+		});
+	});
+}
+
+//#endregion
+export { BinaryResolutionError, cancelDialog, clearPlatformCache, closeBrowser, downloadAsset, emitEvent, error, executeBinary, extractArchive, fetchUrl, fileExists, getMessageContext, getPlatformInfo, getPluginCookie, getTauriCore, isEventApiAvailable, isTauriAvailable, listFiles, listPluginFiles, log, makeExecutable, onEvent, openBrowser, pluginFileExists, readFile, readPluginFile, reportComplete, reportError, reportProgress, resolveBinary, sendMessage, setMessageContext, setPluginCookie, showPluginDialog, submitDialogResult, waitForEvent, warn, writeFile, writePluginFile };
 //# sourceMappingURL=index.mjs.map