emsdk-env 0.10.0 → 0.12.0

package/dist/build-BAcPqsVO.js

@@ -0,0 +1,1379 @@
+/*!
+* name: emsdk-env
+* version: 0.12.0
+* description: Emscripten environment builder
+* author: Kouji Matsui (@kekyo@mi.kekyo.net)
+* license: MIT
+* repository.url: https://github.com/kekyo/emsdk-env
+* git.commit.hash: 13e3966455dae312e6e85f6470003bf7619ec02d
+*/
+import { access, constants, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { dirname, isAbsolute, join, parse, relative, resolve } from "path";
+import { spawn } from "child_process";
+import { glob } from "glob";
+//#region node_modules/async-primitives/dist/index.mjs
+/*!
+* name: async-primitives
+* version: 1.7.0
+* description: A collection of primitive functions for asynchronous operations
+* author: Kouji Matsui (@kekyo@mi.kekyo.net)
+* license: MIT
+* repository.url: https://github.com/kekyo/async-primitives.git
+* git.commit.hash: 9472fbd5310b92690d84aaafb897429a04c013c5
+*/
+/**
+* A no-op Releasable object that does nothing when released or disposed
+*/
+var __NOOP_HANDLER = () => {};
+var __NOOP_RELEASABLE = {
+	release: __NOOP_HANDLER,
+	[Symbol.dispose]: __NOOP_HANDLER
+};
+var toAbortError = (reason) => {
+	if (reason instanceof Error) return reason;
+	if (typeof reason === "string") return new Error(reason);
+	return /* @__PURE__ */ new Error("Operation aborted");
+};
+/**
+* Hooks up an abort handler to an AbortSignal and returns a handle for early cleanup
+* @param signal - The AbortSignal to hook up to
+* @param callback - The callback to call when the signal is aborted
+* @returns A Releasable handle that can be used to remove the abort listener early
+*/
+var onAbort = (signal, callback) => {
+	if (!signal) return __NOOP_RELEASABLE;
+	if (signal.aborted) {
+		try {
+			callback(toAbortError(signal.reason));
+		} catch (error) {
+			console.warn("AbortHook callback error: ", error);
+		}
+		return __NOOP_RELEASABLE;
+	}
+	let abortHandler = () => {
+		if (abortHandler) {
+			const reason = signal.reason;
+			signal.removeEventListener("abort", abortHandler);
+			abortHandler = void 0;
+			try {
+				callback(toAbortError(reason));
+			} catch (error) {
+				console.warn("AbortHook callback error: ", error);
+			}
+		}
+	};
+	const release = () => {
+		if (abortHandler) {
+			signal.removeEventListener("abort", abortHandler);
+			abortHandler = void 0;
+		}
+	};
+	signal.addEventListener("abort", abortHandler, { once: true });
+	return {
+		release,
+		[Symbol.dispose]: release
+	};
+};
+var runtimeGlobal$1 = globalThis;
+var defer = (fn) => {
+	const setImmediateHandler = runtimeGlobal$1.setImmediate;
+	if (typeof setImmediateHandler === "function") {
+		setImmediateHandler(fn);
+		return;
+	}
+	globalThis.setTimeout(fn, 0);
+};
+var ABORTED_ERROR$2 = () => /* @__PURE__ */ new Error("Lock acquisition was aborted");
+/**
+* Creates a new LockHandle instance
+* @param releaseCallback Callback function to release the lock
+* @returns A LockHandle object with release and dispose functionality
+*/
+var createLockHandle = (releaseCallback) => {
+	let isActive = true;
+	const release = () => {
+		if (!isActive) return;
+		isActive = false;
+		releaseCallback();
+	};
+	return {
+		get isActive() {
+			return isActive;
+		},
+		release,
+		[Symbol.dispose]: release
+	};
+};
+/**
+* Creates a new Mutex instance
+* @param maxConsecutiveCalls - The maximum number of consecutive calls to the lockAsync method before yielding control to the next item in the queue
+* @returns A new Mutex for promise-based mutex operations
+*/
+var createMutex = (maxConsecutiveCalls = 20) => {
+	let isLocked = false;
+	const queue = [];
+	let count = 0;
+	const processQueue = () => {
+		var _item$signal;
+		if (isLocked || queue.length === 0) return;
+		const item = queue.shift();
+		if ((_item$signal = item.signal) === null || _item$signal === void 0 ? void 0 : _item$signal.aborted) {
+			item.reject(ABORTED_ERROR$2());
+			scheduleNextProcess();
+			return;
+		}
+		isLocked = true;
+		const lockHandle = createLockHandle(releaseLock);
+		item.resolve(lockHandle);
+	};
+	const scheduleNextProcess = () => {
+		count++;
+		if (count >= maxConsecutiveCalls) {
+			count = 0;
+			defer(processQueue);
+		} else processQueue();
+	};
+	const releaseLock = () => {
+		if (!isLocked) return;
+		isLocked = false;
+		scheduleNextProcess();
+	};
+	const removeFromQueue = (item) => {
+		const index = queue.indexOf(item);
+		if (index !== -1) queue.splice(index, 1);
+	};
+	const lock = async (signal) => {
+		if (signal) {
+			if (signal.aborted) throw ABORTED_ERROR$2();
+			return new Promise((resolve, reject) => {
+				const queueItem = {
+					resolve: void 0,
+					reject: void 0,
+					signal
+				};
+				const abortHandle = onAbort(signal, () => {
+					removeFromQueue(queueItem);
+					reject(ABORTED_ERROR$2());
+				});
+				queueItem.resolve = (handle) => {
+					abortHandle.release();
+					resolve(handle);
+				};
+				queueItem.reject = (error) => {
+					abortHandle.release();
+					reject(error);
+				};
+				queue.push(queueItem);
+				processQueue();
+			});
+		} else return new Promise((resolve, reject) => {
+			queue.push({
+				resolve,
+				reject
+			});
+			processQueue();
+		});
+	};
+	return {
+		lock,
+		waiter: { wait: lock },
+		get isLocked() {
+			return isLocked;
+		},
+		get pendingCount() {
+			return queue.length;
+		}
+	};
+};
+var createLogicalContext = (id) => {
+	return {
+		id,
+		data: /* @__PURE__ */ new Map()
+	};
+};
+createLogicalContext(Symbol("[root]"));
+//#endregion
+//#region src/commands.ts
+var createAbortError = () => {
+	const error = /* @__PURE__ */ new Error("The operation was aborted.");
+	error.name = "AbortError";
+	return error;
+};
+var runCommand = async (command, args, cwd, signal) => {
+	signal === null || signal === void 0 || signal.throwIfAborted();
+	return new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(command, args, {
+			cwd,
+			stdio: "inherit"
+		});
+		let settled = false;
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			child.kill();
+			rejectPromise(createAbortError());
+		};
+		signal === null || signal === void 0 || signal.addEventListener("abort", onAbort, { once: true });
+		const cleanup = () => {
+			signal === null || signal === void 0 || signal.removeEventListener("abort", onAbort);
+		};
+		child.once("error", (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			rejectPromise(error);
+		});
+		child.once("close", (code) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			if (code === 0) {
+				resolvePromise();
+				return;
+			}
+			rejectPromise(/* @__PURE__ */ new Error(`Command failed: ${command} ${args.join(" ")} (exit code ${code})`));
+		});
+	});
+};
+var runCommandWithEnv = async (command, args, cwd, env, signal) => {
+	signal === null || signal === void 0 || signal.throwIfAborted();
+	return new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(command, args, {
+			cwd,
+			env,
+			stdio: "inherit"
+		});
+		let settled = false;
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			child.kill();
+			rejectPromise(createAbortError());
+		};
+		signal === null || signal === void 0 || signal.addEventListener("abort", onAbort, { once: true });
+		const cleanup = () => {
+			signal === null || signal === void 0 || signal.removeEventListener("abort", onAbort);
+		};
+		child.once("error", (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			rejectPromise(error);
+		});
+		child.once("close", (code) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			if (code === 0) {
+				resolvePromise();
+				return;
+			}
+			rejectPromise(/* @__PURE__ */ new Error(`Command failed: ${command} ${args.join(" ")} (exit code ${code})`));
+		});
+	});
+};
+var runCommandCapture = async (command, args, cwd, signal) => {
+	signal === null || signal === void 0 || signal.throwIfAborted();
+	return new Promise((resolvePromise, rejectPromise) => {
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		const child = spawn(command, args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let settled = false;
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			child.kill();
+			rejectPromise(createAbortError());
+		};
+		signal === null || signal === void 0 || signal.addEventListener("abort", onAbort, { once: true });
+		const cleanup = () => {
+			signal === null || signal === void 0 || signal.removeEventListener("abort", onAbort);
+		};
+		child.stdout.on("data", (chunk) => {
+			stdoutChunks.push(chunk);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderrChunks.push(chunk);
+		});
+		child.once("error", (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			rejectPromise(error);
+		});
+		child.once("close", (code) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			if (code === 0) {
+				resolvePromise(Buffer.concat(stdoutChunks));
+				return;
+			}
+			const stderrText = Buffer.concat(stderrChunks).toString("utf8");
+			rejectPromise(/* @__PURE__ */ new Error(`Command failed: ${command} ${args.join(" ")} (exit code ${code})${stderrText ? `\n${stderrText}` : ""}`));
+		});
+	});
+};
+//#endregion
+//#region src/fs-utils.ts
+var pathExists = async (targetPath) => {
+	try {
+		await access(targetPath, constants.F_OK);
+		return true;
+	} catch (_unused) {
+		return false;
+	}
+};
+var ensureDirectory = async (targetPath) => {
+	await mkdir(targetPath, { recursive: true });
+};
+//#endregion
+//#region src/emsdk.ts
+var DEFAULT_REPO_URL = "https://github.com/emscripten-core/emsdk.git";
+var DEFAULT_GIT_REF = "main";
+var DEFAULT_CACHE_DIR = join(homedir(), ".cache", "emsdk-env");
+var DEFAULT_TARGET_VERSION = "latest";
+var versionMutexes = /* @__PURE__ */ new Map();
+var getVersionMutex = (key) => {
+	let mutex = versionMutexes.get(key);
+	if (!mutex) {
+		mutex = createMutex();
+		versionMutexes.set(key, mutex);
+	}
+	return mutex;
+};
+var ensureNonEmpty = (value, label) => {
+	if (value.trim().length === 0) throw new TypeError(`${label} must be a non-empty string.`);
+};
+var sanitizeSegment = (value) => {
+	const trimmed = value.trim();
+	ensureNonEmpty(trimmed, "targetVersion");
+	const sanitized = trimmed.replace(/[^A-Za-z0-9._-]/g, "_");
+	if (sanitized === "." || sanitized === ".." || sanitized.length === 0) throw new TypeError("targetVersion results in an unsafe path segment.");
+	return sanitized;
+};
+var resolveEmsdkCommand = () => process.platform === "win32" ? "emsdk.bat" : "./emsdk";
+var runEmsdk = async (repoDir, args, signal) => {
+	if (process.platform === "win32") {
+		await runCommand("cmd", [
+			"/c",
+			"emsdk.bat",
+			...args
+		], repoDir, signal);
+		return;
+	}
+	await runCommand(resolveEmsdkCommand(), args, repoDir, signal);
+};
+var runGitClone = async (gitPath, repoUrl, targetDir, cwd, signal) => {
+	await runCommand(gitPath, [
+		"clone",
+		repoUrl,
+		targetDir,
+		"--depth",
+		"1",
+		"--branch",
+		DEFAULT_GIT_REF
+	], cwd, signal);
+};
+var isAlreadyExistsError = (error) => error instanceof Error && "code" in error && error.code !== void 0 && [
+	"EEXIST",
+	"ENOTEMPTY",
+	"EISDIR"
+].includes(String(error.code));
+/**
+* Prepare the Emscripten SDK in the local cache and return the SDK root path.
+*
+* Clones the emsdk repository if needed, installs the requested version,
+* and activates it in the cache directory.
+*
+* @param options - SDK preparation options.
+* @returns Absolute path to the prepared SDK root.
+*/
+var prepareEmsdk = async (options) => {
+	var _options$targetVersio, _options$signal, _options$cacheDir, _options$repoUrl, _options$gitPath;
+	if (!options) throw new TypeError("options must be provided.");
+	if (options.targetVersion !== void 0 && typeof options.targetVersion !== "string") throw new TypeError("targetVersion must be a string.");
+	const targetVersion = (_options$targetVersio = options.targetVersion) !== null && _options$targetVersio !== void 0 ? _options$targetVersio : DEFAULT_TARGET_VERSION;
+	ensureNonEmpty(targetVersion, "targetVersion");
+	(_options$signal = options.signal) === null || _options$signal === void 0 || _options$signal.throwIfAborted();
+	const cacheDir = resolve((_options$cacheDir = options.cacheDir) !== null && _options$cacheDir !== void 0 ? _options$cacheDir : DEFAULT_CACHE_DIR);
+	const repoUrl = (_options$repoUrl = options.repoUrl) !== null && _options$repoUrl !== void 0 ? _options$repoUrl : DEFAULT_REPO_URL;
+	const gitPath = (_options$gitPath = options.gitPath) !== null && _options$gitPath !== void 0 ? _options$gitPath : "git";
+	const finalDir = resolve(cacheDir, sanitizeSegment(targetVersion));
+	const lock = await getVersionMutex(finalDir).lock(options.signal);
+	try {
+		var _options$signal2, _options$signal4;
+		(_options$signal2 = options.signal) === null || _options$signal2 === void 0 || _options$signal2.throwIfAborted();
+		if (await pathExists(finalDir)) return finalDir;
+		await ensureDirectory(cacheDir);
+		const tempRoot = await mkdtemp(join(cacheDir, ".tmp-"));
+		const tempRepoDir = join(tempRoot, "emsdk");
+		try {
+			var _options$signal3;
+			await runGitClone(gitPath, repoUrl, tempRepoDir, cacheDir, options.signal);
+			(_options$signal3 = options.signal) === null || _options$signal3 === void 0 || _options$signal3.throwIfAborted();
+			await runEmsdk(tempRepoDir, ["install", targetVersion], options.signal);
+			try {
+				await rename(tempRepoDir, finalDir);
+			} catch (error) {
+				if (isAlreadyExistsError(error)) return finalDir;
+				throw error;
+			}
+		} finally {
+			await rm(tempRoot, {
+				recursive: true,
+				force: true
+			});
+		}
+		(_options$signal4 = options.signal) === null || _options$signal4 === void 0 || _options$signal4.throwIfAborted();
+		await runEmsdk(finalDir, ["activate", targetVersion], options.signal);
+		return finalDir;
+	} finally {
+		lock.release();
+	}
+};
+//#endregion
+//#region src/env.ts
+var shellQuote = (value) => `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
+var parseEnvBuffer = (buffer) => {
+	const entries = buffer.toString("utf8").split("\0");
+	const env = {};
+	for (const entry of entries) {
+		if (!entry) continue;
+		const delimiterIndex = entry.indexOf("=");
+		if (delimiterIndex <= 0) continue;
+		const key = entry.slice(0, delimiterIndex);
+		env[key] = entry.slice(delimiterIndex + 1);
+	}
+	return env;
+};
+var loadEmsdkEnv = async (emsdkRoot, logger, signal) => {
+	if (process.platform === "win32") throw new Error("Emscripten environment extraction on Windows is not implemented yet.");
+	const envScript = resolve(emsdkRoot, "emsdk_env.sh");
+	if (!await pathExists(envScript)) throw new Error(`emsdk_env.sh not found: ${envScript}`);
+	const command = `. ${shellQuote(envScript)} >/dev/null 2>&1; env -0`;
+	logger.debug(`Loading emsdk environment: ${envScript}`);
+	return parseEnvBuffer(await runCommandCapture("bash", ["-lc", command], emsdkRoot, signal));
+};
+var resolveEmccCommand = async (env, emsdkRoot) => {
+	if (env.EMCC) return env.EMCC;
+	if (env.EMSCRIPTEN) {
+		const candidate = join(env.EMSCRIPTEN, "emcc");
+		if (await pathExists(candidate)) return candidate;
+	}
+	const fallback = join(emsdkRoot, "upstream", "emscripten", "emcc");
+	if (await pathExists(fallback)) return fallback;
+	return "emcc";
+};
+var resolveEmarCommand = async (env, emsdkRoot) => {
+	if (env.EMAR) return env.EMAR;
+	if (env.EMSCRIPTEN) {
+		const candidate = join(env.EMSCRIPTEN, "emar");
+		if (await pathExists(candidate)) return candidate;
+	}
+	const fallback = join(emsdkRoot, "upstream", "emscripten", "emar");
+	if (await pathExists(fallback)) return fallback;
+	return "emar";
+};
+var resolveWasmOptCommand = async (env, emsdkRoot) => {
+	var _env$BINARYEN_ROOT;
+	if (env.WASM_OPT) return env.WASM_OPT;
+	const binaryenRoot = (_env$BINARYEN_ROOT = env.BINARYEN_ROOT) !== null && _env$BINARYEN_ROOT !== void 0 ? _env$BINARYEN_ROOT : env.BINARYEN;
+	if (binaryenRoot) {
+		const candidate = join(binaryenRoot, "bin", "wasm-opt");
+		if (await pathExists(candidate)) return candidate;
+	}
+	const fallback = join(emsdkRoot, "upstream", "bin", "wasm-opt");
+	if (await pathExists(fallback)) return fallback;
+	return "wasm-opt";
+};
+//#endregion
+//#region src/logger.ts
+var createConsoleLogger = (prefix) => {
+	return {
+		debug: (msg) => console.debug(`[${prefix}]: ${msg}`),
+		info: (msg) => console.info(`[${prefix}]: ${msg}`),
+		warn: (msg) => console.warn(`[${prefix}]: ${msg}`),
+		error: (msg) => console.error(`[${prefix}]: ${msg}`)
+	};
+};
+//#endregion
+//#region src/build.ts
+var DEFAULT_WASM_SRC_DIR = "wasm";
+var DEFAULT_WASM_INCLUDE_DIR = "include";
+var DEFAULT_WASM_OUT_DIR = join("src", "wasm");
+var DEFAULT_WASM_LIB_DIR = "lib";
+var DEFAULT_IMPORT_INCLUDE_DIR = "include";
+var DEFAULT_IMPORT_LIB_DIR = "lib";
+var DEFAULT_WASM_BUILD_DIR = join(tmpdir(), "emsdk-env");
+var DEFAULT_EMSDK_TARGET_VERSION = "latest";
+var DEFAULT_WASM_OPT_ARGS = ["-Oz"];
+var DEFAULT_GENERATED_LOADER_OUT_FILE = join("src", "generated", "wasm-loader.ts");
+var buildSequence = 0;
+var padNumber = (value, length = 2) => String(value).padStart(length, "0");
+var formatTimestamp = (date) => {
+	return `${date.getFullYear()}${padNumber(date.getMonth() + 1)}${padNumber(date.getDate())}_${padNumber(date.getHours())}${padNumber(date.getMinutes())}${padNumber(date.getSeconds())}`;
+};
+var createBuildId = () => {
+	buildSequence += 1;
+	return `${formatTimestamp(/* @__PURE__ */ new Date())}_${String(buildSequence).padStart(4, "0")}_${process.pid}`;
+};
+var ensureArray = (value) => value !== null && value !== void 0 ? value : [];
+var resolveTargetType = (value) => value !== null && value !== void 0 ? value : "wasm";
+var normalizePrepareOptions = (options) => {
+	const { targetVersion, ...rest } = options !== null && options !== void 0 ? options : {};
+	return {
+		targetVersion: targetVersion !== null && targetVersion !== void 0 ? targetVersion : DEFAULT_EMSDK_TARGET_VERSION,
+		...rest
+	};
+};
+var parseStringKeyValueInput = (values) => {
+	const parsed = {};
+	for (const entry of values) {
+		const index = entry.indexOf("=");
+		if (index === -1) {
+			parsed[entry] = void 0;
+			continue;
+		}
+		const key = entry.slice(0, index);
+		parsed[key] = entry.slice(index + 1);
+	}
+	return parsed;
+};
+var isDefineMap = (input) => input instanceof Map;
+var normalizeDefineInput = (input) => {
+	if (!input) return {};
+	if (Array.isArray(input)) return parseStringKeyValueInput(input);
+	if (isDefineMap(input)) return Object.fromEntries(input);
+	return { ...input };
+};
+var isLinkDirectiveMap = (input) => input instanceof Map;
+var normalizeLinkDirectiveInput = (input) => {
+	if (!input) return {};
+	if (Array.isArray(input)) return parseStringKeyValueInput(input);
+	if (isLinkDirectiveMap(input)) return Object.fromEntries(input);
+	return { ...input };
+};
+var mergeDefines = (common, target) => ({
+	...normalizeDefineInput(common),
+	...normalizeDefineInput(target)
+});
+var mergeLinkDirectives = (common, target) => ({
+	...normalizeLinkDirectiveInput(common),
+	...normalizeLinkDirectiveInput(target)
+});
+var resolveWasmOptEnabled = (common, target) => {
+	var _ref, _target$enable;
+	return (_ref = (_target$enable = target === null || target === void 0 ? void 0 : target.enable) !== null && _target$enable !== void 0 ? _target$enable : common === null || common === void 0 ? void 0 : common.enable) !== null && _ref !== void 0 ? _ref : false;
+};
+var resolveWasmOptArgs = (common, target, env) => {
+	var _common$options, _target$options;
+	const commonArgs = (_common$options = common === null || common === void 0 ? void 0 : common.options) !== null && _common$options !== void 0 ? _common$options : DEFAULT_WASM_OPT_ARGS;
+	const targetArgs = (_target$options = target === null || target === void 0 ? void 0 : target.options) !== null && _target$options !== void 0 ? _target$options : [];
+	return expandArray([...commonArgs, ...targetArgs], env, "wasmOpt.options");
+};
+var stripOuterQuotes = (value) => {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	return trimmed;
+};
+var extractWasmBinaryFile = (value) => {
+	if (value.startsWith("WASM_BINARY_FILE=")) return value.slice(17);
+	const match = value.match(/^(?:-s|--settings)(?:=)?WASM_BINARY_FILE=(.+)$/);
+	if (match) return match[1];
+};
+var resolveWasmBinaryFileFromLinkOptions = (linkOptions) => {
+	for (let index = 0; index < linkOptions.length; index += 1) {
+		const option = linkOptions[index];
+		if (!option) continue;
+		if (option === "-s" || option === "--settings") {
+			const next = linkOptions[index + 1];
+			if (!next) continue;
+			const extracted = extractWasmBinaryFile(next);
+			if (extracted) return stripOuterQuotes(extracted);
+		}
+		const extracted = extractWasmBinaryFile(option);
+		if (extracted) return stripOuterQuotes(extracted);
+	}
+};
+var resolveWasmOptInputFile = (resolvedOutFile, resolvedLinkOptions) => {
+	const wasmBinaryFile = resolveWasmBinaryFileFromLinkOptions(resolvedLinkOptions);
+	if (wasmBinaryFile) return isAbsolute(wasmBinaryFile) ? wasmBinaryFile : resolve(dirname(resolvedOutFile), wasmBinaryFile);
+	const parsed = parse(resolvedOutFile);
+	if (parsed.ext.toLowerCase() === ".wasm") return resolvedOutFile;
+	const baseName = parsed.name.toLowerCase().endsWith(".wasm") ? parsed.name : `${parsed.name}.wasm`;
+	return join(parsed.dir, baseName);
+};
+var resolvePath = (rootDir, value) => isAbsolute(value) ? value : resolve(rootDir, value);
+var expandPlaceholders = (value, env, label) => value.replace(/\{([A-Z0-9_]+)\}/g, (_match, key) => {
+	const replacement = env[key];
+	if (replacement === void 0) throw new Error(`Unknown placeholder {${key}} in ${label}.`);
+	return replacement;
+});
+var expandArray = (values, env, label) => values.map((value) => expandPlaceholders(value, env, label));
+var resolveDefines = (defines, env) => {
+	const resolved = {};
+	for (const [key, value] of Object.entries(defines)) if (typeof value === "string") resolved[key] = expandPlaceholders(value, env, `defines.${key}`);
+	else resolved[key] = value;
+	return resolved;
+};
+var resolveLinkDirectiveValue = (value, env, label) => {
+	if (typeof value === "string") return expandPlaceholders(value, env, label);
+	if (Array.isArray(value)) return value.map((entry, index) => expandPlaceholders(entry, env, `${label}[${index}]`));
+	return value;
+};
+var resolveLinkDirectives = (directives, env) => {
+	const resolved = {};
+	for (const [key, value] of Object.entries(directives)) resolved[key] = resolveLinkDirectiveValue(value, env, `linkDirectives.${key}`);
+	return resolved;
+};
+var resolveIncludeDirs = (includeDirs, env, rootDir) => {
+	return expandArray(includeDirs, env, "includeDirs").map((value) => resolvePath(rootDir, value));
+};
+var resolveOutFile = (outFile, env, outDir) => {
+	return resolvePath(outDir, expandPlaceholders(outFile, env, "outFile"));
+};
+var resolveSourcesFromPatterns = async (patterns, env, srcDir, label) => {
+	const resolvedPatterns = expandArray(patterns, env, label).map((value) => resolvePath(srcDir, value));
+	const sources = (await Promise.all(resolvedPatterns.map((pattern) => glob(pattern, { nodir: true })))).flat();
+	sources.sort();
+	return sources;
+};
+var buildDefineFlags = (defines) => Object.entries(defines).flatMap(([key, value]) => value === null || value === void 0 ? [`-D${key}`] : [`-D${key}=${String(value)}`]);
+var serializeLinkDirectiveValue = (value) => Array.isArray(value) ? JSON.stringify(value) : String(value);
+var buildLinkDirectiveFlags = (directives) => {
+	if (Object.keys(directives).length === 0) return [];
+	return Object.entries(directives).flatMap(([key, value]) => value === null || value === void 0 ? ["-s", key] : ["-s", `${key}=${serializeLinkDirectiveValue(value)}`]);
+};
+var buildExportFlags = (exports) => {
+	if (exports.length === 0) return [];
+	return ["-s", `EXPORTED_FUNCTIONS=${JSON.stringify(exports)}`];
+};
+var createEnvForBuild = (baseEnv, overrides) => ({
+	...process.env,
+	...baseEnv,
+	...overrides
+});
+var resolveTargetOutFile = (targetName, targetOutFile, env, baseDir, extension) => {
+	if (targetOutFile) return resolveOutFile(targetOutFile, env, baseDir);
+	return resolve(baseDir, `${targetName}.${extension}`);
+};
+var resolveTargetSources = async (targetSources, env, srcDir) => {
+	return resolveSourcesFromPatterns(targetSources && targetSources.length > 0 ? targetSources : [join(srcDir, "**", "*.c"), join(srcDir, "**", "*.cpp")], env, srcDir, "sources");
+};
+var toSafeObjectName = (rootDir, sourcePath, groupIndex) => {
+	const baseName = relative(rootDir, sourcePath).replace(/[\\/]/g, "_").replace(/[^A-Za-z0-9._-]/g, "_");
+	if (groupIndex === void 0) return baseName;
+	return `${baseName}__g${groupIndex}`;
+};
+var dedupeSources = (sources) => {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const source of sources) {
+		if (seen.has(source)) continue;
+		seen.add(source);
+		deduped.push(source);
+	}
+	return deduped;
+};
+var dedupeValues = (values) => {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const value of values) {
+		if (seen.has(value)) continue;
+		seen.add(value);
+		deduped.push(value);
+	}
+	return deduped;
+};
+var isSubPath = (parentDir, targetPath) => {
+	const rel = relative(parentDir, targetPath);
+	if (rel === "") return true;
+	return !rel.startsWith("..") && !isAbsolute(rel);
+};
+var readTextIfExists = async (filePath) => {
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+};
+var writeTextIfChanged = async (filePath, content) => {
+	if (await readTextIfExists(filePath) === content) return false;
+	await ensureDirectory(dirname(filePath));
+	await writeFile(filePath, content, "utf8");
+	return true;
+};
+var toPascalCaseIdentifier = (value) => {
+	const tokens = value.split(/[^A-Za-z0-9]+/).map((token) => token.trim()).filter((token) => token.length > 0);
+	if (tokens.length === 0) throw new Error(`Cannot derive loader function name from target: ${value}`);
+	const pascal = tokens.map((token) => token.charAt(0).toUpperCase() + token.slice(1)).join("");
+	return /^[0-9]/.test(pascal) ? `Target${pascal}` : pascal;
+};
+var toRelativeImportSpecifier = (fromFile, toFile) => {
+	const rel = relative(dirname(fromFile), toFile).replace(/\\/g, "/");
+	return rel.startsWith(".") ? rel : `./${rel}`;
+};
+var buildGeneratedLoaderContent = (generatedLoaderFile, targets) => {
+	return `// Generated by emsdk-env. DO NOT EDIT.
+
+/**
+ * Supported input sources for loading a WASM binary.
+ */
+export type WasmSource =
+  | string
+  | URL
+  | ArrayBuffer
+  | ArrayBufferView
+  | Response;
+
+/**
+ * Options for instantiating a WASM module.
+ */
+export interface WasmLoadOptions {
+  /**
+   * Imports passed to WebAssembly.instantiate().
+   */
+  readonly imports?: WebAssembly.Imports;
+}
+
+/**
+ * Options for loading a generated WASM target.
+ */
+export interface TargetWasmLoadOptions extends WasmLoadOptions {
+  /**
+   * Override the generated default source for the target.
+   */
+  readonly source?: WasmSource;
+}
+
+const isResponse = (value: WasmSource): value is Response =>
+  typeof Response !== 'undefined' && value instanceof Response;
+
+const createWasmLoadOptions = (
+  imports: WebAssembly.Imports | undefined
+): WasmLoadOptions | undefined => (imports ? { imports } : undefined);
+
+/**
+ * Instantiated WASM module with typed export helpers.
+ *
+ * @typeParam TExports Function exports exposed through the exports property.
+ * @typeParam TAllExports Full WebAssembly export map exposed through the allExports property.
+ */
+export interface WasmInstance<
+  TExports extends object = Record<string, (...args: unknown[]) => unknown>,
+  TAllExports extends WebAssembly.Exports = WebAssembly.Exports> {
+  /**
+   * Exported functions only.
+   */
+  readonly exports: TExports;
+  /**
+   * All exported values with caller-provided typing.
+   */
+  readonly allExports: TAllExports;
+  /**
+   * Resolved linear memory used by the module.
+   */
+  readonly memory: WebAssembly.Memory;
+  /**
+   * Resolved function table when the module uses one.
+   */
+  readonly table: WebAssembly.Table | undefined;
+  /**
+   * Raw exports object returned by WebAssembly.instantiate().
+   */
+  readonly rawExports: WebAssembly.Exports;
+  /**
+   * Compiled WebAssembly module.
+   */
+  readonly module: WebAssembly.Module;
+  /**
+   * Instantiated WebAssembly instance.
+   */
+  readonly instance: WebAssembly.Instance;
+  /**
+   * Optional Emscripten _initialize export.
+   */
+  readonly initialize: (() => unknown) | undefined;
+  /**
+   * Optional WASI _start export.
+   */
+  readonly start: (() => unknown) | undefined;
+}
+
+const resolveWasmBytes = async (source: WasmSource): Promise<ArrayBuffer> => {
+  if (isResponse(source)) {
+    return await source.arrayBuffer();
+  }
+  if (source instanceof URL || typeof source === 'string') {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(\`Failed to fetch wasm: \${response.url}\`);
+    }
+    return await response.arrayBuffer();
+  }
+  if (source instanceof ArrayBuffer) {
+    return source;
+  }
+  if (ArrayBuffer.isView(source)) {
+    const view = new Uint8Array(
+      source.buffer,
+      source.byteOffset,
+      source.byteLength
+    );
+    return view.slice().buffer;
+  }
+  throw new TypeError('Unsupported wasm source.');
+};
+
+const getImportValue = (
+  imports: WebAssembly.Imports | undefined,
+  moduleName: string,
+  name: string
+) => {
+  const moduleImports = imports?.[moduleName];
+  if (!moduleImports || typeof moduleImports !== 'object') {
+    return undefined;
+  }
+  return (moduleImports as Record<string, unknown>)[name];
+};
+
+const resolveMemory = (
+  module: WebAssembly.Module,
+  instance: WebAssembly.Instance,
+  imports: WebAssembly.Imports | undefined
+) => {
+  let memory: WebAssembly.Memory | undefined;
+  for (const entry of WebAssembly.Module.exports(module)) {
+    if (entry.kind !== 'memory') {
+      continue;
+    }
+    if (memory) {
+      throw new Error('Multiple wasm memories are not supported.');
+    }
+    const value = instance.exports[entry.name];
+    if (!(value instanceof WebAssembly.Memory)) {
+      throw new Error(\`Export is not a WebAssembly.Memory: \${entry.name}\`);
+    }
+    memory = value;
+  }
+  if (memory) {
+    return memory;
+  }
+  for (const entry of WebAssembly.Module.imports(module)) {
+    if (entry.kind !== 'memory') {
+      continue;
+    }
+    if (memory) {
+      throw new Error('Multiple wasm memories are not supported.');
+    }
+    const value = getImportValue(imports, entry.module, entry.name);
+    if (!(value instanceof WebAssembly.Memory)) {
+      throw new Error(
+        \`Imported value is not a WebAssembly.Memory: \${entry.module}.\${entry.name}\`
+      );
+    }
+    memory = value;
+  }
+  if (!memory) {
+    throw new Error('WASM memory export/import was not resolved.');
+  }
+  return memory;
+};
+
+const resolveTable = (
+  module: WebAssembly.Module,
+  instance: WebAssembly.Instance,
+  imports: WebAssembly.Imports | undefined
+) => {
+  let table: WebAssembly.Table | undefined;
+  for (const entry of WebAssembly.Module.exports(module)) {
+    if (entry.kind !== 'table') {
+      continue;
+    }
+    if (table) {
+      throw new Error('Multiple wasm tables are not supported.');
+    }
+    const value = instance.exports[entry.name];
+    if (!(value instanceof WebAssembly.Table)) {
+      throw new Error(\`Export is not a WebAssembly.Table: \${entry.name}\`);
+    }
+    table = value;
+  }
+  if (table) {
+    return table;
+  }
+  for (const entry of WebAssembly.Module.imports(module)) {
+    if (entry.kind !== 'table') {
+      continue;
+    }
+    if (table) {
+      throw new Error('Multiple wasm tables are not supported.');
+    }
+    const value = getImportValue(imports, entry.module, entry.name);
+    if (!(value instanceof WebAssembly.Table)) {
+      throw new Error(
+        \`Imported value is not a WebAssembly.Table: \${entry.module}.\${entry.name}\`
+      );
+    }
+    table = value;
+  }
+  return table;
+};
+
+/**
+ * Load and instantiate a WASM module from the provided source.
+ *
+ * @typeParam TExports Function exports exposed through the exports property.
+ * @typeParam TAllExports Full WebAssembly export map exposed through the allExports property.
+ * @param source WASM source to load.
+ * @param options WebAssembly instantiation options.
+ * @returns The instantiated WASM module and resolved runtime handles.
+ */
+export const loadWasm = async <
+  TExports extends object = Record<string, (...args: unknown[]) => unknown>,
+  TAllExports extends WebAssembly.Exports = WebAssembly.Exports>(
+  source: WasmSource,
+  options?: WasmLoadOptions
+): Promise<WasmInstance<TExports, TAllExports>> => {
+  const bytes = await resolveWasmBytes(source);
+  const module = await WebAssembly.compile(bytes);
+  const instance = await WebAssembly.instantiate(module, options?.imports ?? {});
+
+  const functionExports: Record<string, (...args: unknown[]) => unknown> = {};
+  for (const entry of WebAssembly.Module.exports(module)) {
+    if (entry.kind !== 'function') {
+      continue;
+    }
+    const value = instance.exports[entry.name];
+    if (typeof value !== 'function') {
+      throw new Error(\`Export is not a function: \${entry.name}\`);
+    }
+    functionExports[entry.name] = value as (...args: unknown[]) => unknown;
+  }
+
+  const initialize =
+    typeof instance.exports._initialize === 'function'
+      ? (instance.exports._initialize as () => unknown)
+      : undefined;
+  const start =
+    typeof instance.exports._start === 'function'
+      ? (instance.exports._start as () => unknown)
+      : undefined;
+
+  return {
+    exports: functionExports as TExports,
+    allExports: instance.exports as TAllExports,
+    memory: resolveMemory(module, instance, options?.imports),
+    table: resolveTable(module, instance, options?.imports),
+    rawExports: instance.exports,
+    module,
+    instance,
+    initialize,
+    start,
+  };
+};
+
+${targets.map((target) => {
+		const defaultSourceSpecifier = toRelativeImportSpecifier(generatedLoaderFile, target.outFile);
+		const specifier = JSON.stringify(defaultSourceSpecifier);
+		return `/**
+ * Load and instantiate the generated "${target.targetName}" WASM target.
+ *
+ * @typeParam TExports Function exports exposed through the exports property.
+ * @typeParam TAllExports Full WebAssembly export map exposed through the allExports property.
+ * @param options Override the target source or WebAssembly imports.
+ * @returns The instantiated WASM target and resolved runtime handles.
+ * @remarks When options.source is omitted, the loader resolves "${defaultSourceSpecifier}" relative to this file.
+ */
+export const ${target.functionName} = async <
+  TExports extends object = Record<string, (...args: unknown[]) => unknown>,
+  TAllExports extends WebAssembly.Exports = WebAssembly.Exports>(
+  options?: TargetWasmLoadOptions
+): Promise<WasmInstance<TExports, TAllExports>> => {
+  const source = options?.source ?? new URL(${specifier}, import.meta.url);
+  return await loadWasm<TExports, TAllExports>(source, createWasmLoadOptions(options?.imports));
+};`;
+	}).join("\n\n")}
+`;
+};
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var resolvePackageJsonPath = async (startPath, packageName) => {
+	let current = dirname(startPath);
+	for (;;) {
+		const candidate = join(current, "package.json");
+		if (await pathExists(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) throw new Error(`package.json not found for import: ${packageName}`);
+		current = parent;
+	}
+};
+var loadPackageJson = async (packageJsonPath, packageName) => {
+	try {
+		const raw = await readFile(packageJsonPath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!isRecord(parsed)) throw new Error("package.json must be an object.");
+		return parsed;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to read package.json for import ${packageName}: ${message}`);
+	}
+};
+var resolveImportPaths = async (resolver, packageName) => {
+	let resolvedEntry;
+	try {
+		resolvedEntry = resolver.resolve(packageName);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to resolve import ${packageName}: ${message}`);
+	}
+	const packageJsonPath = await resolvePackageJsonPath(resolvedEntry, packageName);
+	const packageRoot = dirname(packageJsonPath);
+	const emsdkConfigRaw = (await loadPackageJson(packageJsonPath, packageName))["emsdk-env"];
+	if (emsdkConfigRaw !== void 0 && !isRecord(emsdkConfigRaw)) throw new Error(`Invalid emsdk-env config for import ${packageName}: expected an object.`);
+	const includeRaw = isRecord(emsdkConfigRaw) ? emsdkConfigRaw.include : void 0;
+	if (includeRaw !== void 0 && typeof includeRaw !== "string") throw new Error(`Invalid emsdk-env include for import ${packageName}: expected a string.`);
+	const libRaw = isRecord(emsdkConfigRaw) ? emsdkConfigRaw.lib : void 0;
+	if (libRaw !== void 0 && typeof libRaw !== "string") throw new Error(`Invalid emsdk-env lib for import ${packageName}: expected a string.`);
+	const includeRel = includeRaw !== null && includeRaw !== void 0 ? includeRaw : DEFAULT_IMPORT_INCLUDE_DIR;
+	const libRel = libRaw !== null && libRaw !== void 0 ? libRaw : DEFAULT_IMPORT_LIB_DIR;
+	const includeDir = resolve(packageRoot, includeRel);
+	const libDir = resolve(packageRoot, libRel);
+	const includeExists = await pathExists(includeDir);
+	const libExists = await pathExists(libDir);
+	if (!includeExists && !libExists) throw new Error(`Import ${packageName} does not provide include or lib directories.`);
+	return {
+		includeDir: includeExists ? includeDir : void 0,
+		libDir: libExists ? libDir : void 0
+	};
+};
+var resolveImportDirectories = async (rootDir, imports) => {
+	if (imports.length === 0) return {
+		includeDirs: [],
+		libDirs: []
+	};
+	const resolver = (await import("node:module")).createRequire(resolve(rootDir, "package.json"));
+	const includeDirs = [];
+	const libDirs = [];
+	for (const packageName of imports) {
+		const resolved = await resolveImportPaths(resolver, packageName);
+		if (resolved.includeDir) includeDirs.push(resolved.includeDir);
+		if (resolved.libDir) libDirs.push(resolved.libDir);
+	}
+	return {
+		includeDirs: dedupeValues(includeDirs),
+		libDirs: dedupeValues(libDirs)
+	};
+};
+var resolveGeneratedLoaderOutFile = (rootDir, env, generatedLoader) => {
+	var _generatedLoader$outF;
+	if (!(generatedLoader === null || generatedLoader === void 0 ? void 0 : generatedLoader.enable)) return;
+	return resolvePath(rootDir, expandPlaceholders((_generatedLoader$outF = generatedLoader.outFile) !== null && _generatedLoader$outF !== void 0 ? _generatedLoader$outF : DEFAULT_GENERATED_LOADER_OUT_FILE, env, "generatedLoader.outFile"));
+};
+var resolveGeneratedLoaderWatchDirs = (rootDir, srcDir, commonIncludeDirs, env, targetEntries, importIncludeDirs) => {
+	const dirs = [srcDir, ...resolveIncludeDirs(commonIncludeDirs, env, rootDir)];
+	for (const [targetName, target] of targetEntries) {
+		if (!target.includeDirs || target.includeDirs.length === 0) continue;
+		const targetEnv = {
+			...env,
+			TARGET_NAME: targetName
+		};
+		dirs.push(...resolveIncludeDirs(target.includeDirs, targetEnv, rootDir));
+	}
+	dirs.push(...importIncludeDirs);
+	return dedupeValues(dirs);
+};
+var validateGeneratedLoaderOutFile = (generatedLoaderFile, watchDirs) => {
+	for (const dir of watchDirs) if (isSubPath(dir, generatedLoaderFile)) throw new Error(`generatedLoader.outFile must not be placed under watched directory: ${generatedLoaderFile}`);
+};
+var buildCompileArgs = (options, includeDirs, defines, env, rootDir) => {
+	return {
+		resolvedOptions: expandArray(options, env, "options"),
+		includeArgs: resolveIncludeDirs(includeDirs, env, rootDir).map((dir) => `-I${dir}`),
+		defineArgs: buildDefineFlags(resolveDefines(defines, env))
+	};
+};
+/**
+* Build WASM binaries (and optional archives) from C/C++ sources using emsdk.
+*
+* Resolves the SDK via prepareEmsdk, expands build paths, compiles sources,
+* links targets, and returns output paths keyed by target name.
+*
+* @param options - Build options including rule definitions and shared settings.
+* @returns Build result with the resolved SDK root and output file paths.
+*/
+var buildWasm = async (options) => {
+	var _options$logger, _options$root, _options$srcDir, _options$includeDir, _options$outDir, _options$libDir, _options$buildDir, _options$cleanupBuild, _options$parallel, _options$rule$common;
+	if (!options) throw new TypeError("options must be provided.");
+	if (!options.rule || !options.rule.targets) throw new TypeError("rule targets must be provided.");
+	const targetEntries = Object.entries(options.rule.targets);
+	if (targetEntries.length === 0) throw new TypeError("rule targets must not be empty.");
+	const logger = (_options$logger = options.logger) !== null && _options$logger !== void 0 ? _options$logger : createConsoleLogger("emsdk-env");
+	const rootDir = resolve((_options$root = options.root) !== null && _options$root !== void 0 ? _options$root : process.cwd());
+	const emsdkOptions = normalizePrepareOptions(options.emsdk);
+	const emsdkRoot = await prepareEmsdk(emsdkOptions);
+	const emsdkEnv = await loadEmsdkEnv(emsdkRoot, logger, emsdkOptions.signal);
+	const baseEnv = {
+		...emsdkEnv,
+		ROOT: rootDir
+	};
+	const rawSrcDir = expandPlaceholders((_options$srcDir = options.srcDir) !== null && _options$srcDir !== void 0 ? _options$srcDir : DEFAULT_WASM_SRC_DIR, baseEnv, "srcDir");
+	const rawIncludeDir = expandPlaceholders((_options$includeDir = options.includeDir) !== null && _options$includeDir !== void 0 ? _options$includeDir : DEFAULT_WASM_INCLUDE_DIR, baseEnv, "includeDir");
+	const rawOutDir = expandPlaceholders((_options$outDir = options.outDir) !== null && _options$outDir !== void 0 ? _options$outDir : DEFAULT_WASM_OUT_DIR, baseEnv, "outDir");
+	const rawLibDir = expandPlaceholders((_options$libDir = options.libDir) !== null && _options$libDir !== void 0 ? _options$libDir : DEFAULT_WASM_LIB_DIR, baseEnv, "libDir");
+	const rawBuildDir = expandPlaceholders((_options$buildDir = options.buildDir) !== null && _options$buildDir !== void 0 ? _options$buildDir : DEFAULT_WASM_BUILD_DIR, baseEnv, "buildDir");
+	const srcDir = resolvePath(rootDir, rawSrcDir);
+	const includeDir = resolvePath(rootDir, rawIncludeDir);
+	const outDir = resolvePath(rootDir, rawOutDir);
+	const libDir = resolvePath(rootDir, rawLibDir);
+	const buildDir = resolvePath(rootDir, rawBuildDir);
+	const buildId = createBuildId();
+	const buildRunDir = resolve(buildDir, buildId);
+	const cleanupBuildDir = (_options$cleanupBuild = options.cleanupBuildDir) !== null && _options$cleanupBuild !== void 0 ? _options$cleanupBuild : true;
+	const parallel = (_options$parallel = options.parallel) !== null && _options$parallel !== void 0 ? _options$parallel : true;
+	const envWithDirs = {
+		...emsdkEnv,
+		ROOT: rootDir,
+		SRC_DIR: srcDir,
+		INCLUDE_DIR: includeDir,
+		OUT_DIR: outDir,
+		LIB_DIR: libDir,
+		BUILD_DIR: buildDir
+	};
+	const emccCommand = await resolveEmccCommand(envWithDirs, emsdkRoot);
+	const common = (_options$rule$common = options.rule.common) !== null && _options$rule$common !== void 0 ? _options$rule$common : {};
+	const commonIncludeDirs = common.includeDirs === void 0 ? [includeDir] : common.includeDirs;
+	const importDirectories = await resolveImportDirectories(rootDir, ensureArray(options.imports));
+	const importIncludeDirs = importDirectories.includeDirs;
+	const importLibDirs = importDirectories.libDirs;
+	const linkLibDirs = dedupeValues([libDir, ...importLibDirs]);
+	const generatedLoaderFile = resolveGeneratedLoaderOutFile(rootDir, envWithDirs, options.generatedLoader);
+	if (generatedLoaderFile) validateGeneratedLoaderOutFile(generatedLoaderFile, resolveGeneratedLoaderWatchDirs(rootDir, srcDir, commonIncludeDirs, envWithDirs, targetEntries, importIncludeDirs));
+	logger.debug(`Detected rootDir: '${rootDir}'`);
+	logger.debug(`Detected srcDir: '${srcDir}'`);
+	logger.debug(`Detected outDir: '${outDir}'`);
+	logger.debug(`Detected libDir: '${libDir}'`);
+	logger.debug(`Detected buildDir: '${buildDir}'`);
+	logger.debug(`Detected buildId: '${buildId}'`);
+	logger.debug(`Detected buildRunDir: '${buildRunDir}'`);
+	logger.debug(`Detected cleanupBuildDir: ${cleanupBuildDir}`);
+	logger.debug(`Detected parallel: ${parallel}`);
+	logger.debug(`Detected emccCommand: '${emccCommand}'`);
+	logger.debug(`Detected importIncludeDirs: [${importIncludeDirs.map((p) => `'${p}'`).join(",")}]`);
+	logger.debug(`Detected importLibDirs: [${importLibDirs.map((p) => `'${p}'`).join(",")}]`);
+	if (generatedLoaderFile) logger.debug(`Detected generatedLoaderFile: '${generatedLoaderFile}'`);
+	await ensureDirectory(outDir);
+	await ensureDirectory(libDir);
+	await ensureDirectory(buildDir);
+	await rm(buildRunDir, {
+		recursive: true,
+		force: true
+	});
+	await ensureDirectory(buildRunDir);
+	const emarCommand = targetEntries.some(([, target]) => resolveTargetType(target.type) === "archive") ? await resolveEmarCommand(envWithDirs, emsdkRoot) : void 0;
+	if (emarCommand) logger.debug(`Detected emarCommand: '${emarCommand}'`);
+	let wasmOptCommand;
+	const getWasmOptCommand = async () => {
+		if (wasmOptCommand) return wasmOptCommand;
+		wasmOptCommand = await resolveWasmOptCommand(envWithDirs, emsdkRoot);
+		logger.debug(`Detected wasmOptCommand: '${wasmOptCommand}'`);
+		return wasmOptCommand;
+	};
+	const outFiles = {};
+	let resultGeneratedLoaderFile;
+	const buildTargets = async (expectedType) => {
+		for (const [targetName, target] of targetEntries) {
+			var _target$sourceGroups;
+			const targetType = resolveTargetType(target.type);
+			if (targetType !== expectedType) continue;
+			if (targetType === "archive") {
+				if (target.linkOptions !== void 0) throw new Error(`linkOptions is not supported for archive target: ${targetName}`);
+				if (target.linkDirectives !== void 0) throw new Error(`linkDirectives is not supported for archive target: ${targetName}`);
+				if (target.exports !== void 0) throw new Error(`exports is not supported for archive target: ${targetName}`);
+				if (target.wasmOpt !== void 0) throw new Error(`wasmOpt is not supported for archive target: ${targetName}`);
+			}
+			const mergedLinkOptions = targetType === "archive" ? [] : [...ensureArray(common.linkOptions), ...ensureArray(target.linkOptions)];
+			const mergedLinkDirectives = targetType === "archive" ? {} : mergeLinkDirectives(common.linkDirectives, target.linkDirectives);
+			const mergedExports = targetType === "archive" ? [] : [...ensureArray(common.exports), ...ensureArray(target.exports)];
+			const wasmOptEnabled = targetType === "archive" ? false : resolveWasmOptEnabled(common.wasmOpt, target.wasmOpt);
+			const baseCompileOptions = [...ensureArray(common.options), ...ensureArray(target.options)];
+			const baseIncludeDirs = [
+				...ensureArray(commonIncludeDirs),
+				...ensureArray(target.includeDirs),
+				...importIncludeDirs
+			];
+			const baseDefines = mergeDefines(common.defines, target.defines);
+			const sourceGroups = (_target$sourceGroups = target.sourceGroups) !== null && _target$sourceGroups !== void 0 ? _target$sourceGroups : [];
+			const targetEnv = {
+				...envWithDirs,
+				TARGET_NAME: targetName
+			};
+			const buildEnv = createEnvForBuild(targetEnv, {});
+			const resolvedOutFile = resolveTargetOutFile(targetName, target.outFile, targetEnv, targetType === "archive" ? libDir : outDir, targetType === "archive" ? "a" : "wasm");
+			const sources = await resolveTargetSources(target.sources, targetEnv, srcDir);
+			const groupSources = sourceGroups.map(() => []);
+			const groupSourceSet = /* @__PURE__ */ new Set();
+			for (let index = 0; index < sourceGroups.length; index += 1) {
+				const group = sourceGroups[index];
+				if (!group) continue;
+				const deduped = dedupeSources(await resolveSourcesFromPatterns(group.sources, targetEnv, srcDir, `sourceGroups[${index}].sources`));
+				groupSources[index] = deduped;
+				for (const source of deduped) groupSourceSet.add(source);
+			}
+			const baseSources = sources.filter((source) => !groupSourceSet.has(source));
+			const groupedSources = groupSources.flat();
+			if (baseSources.length + groupedSources.length === 0) throw new Error(`No sources matched for target: ${targetName}`);
+			const targetBuildDir = resolve(buildRunDir, targetName);
+			await rm(targetBuildDir, {
+				recursive: true,
+				force: true
+			});
+			await ensureDirectory(targetBuildDir);
+			const linkDirectiveArgs = buildLinkDirectiveFlags(targetType === "archive" ? {} : resolveLinkDirectives(mergedLinkDirectives, targetEnv));
+			const resolvedLinkOptions = targetType === "archive" ? [] : [...linkDirectiveArgs, ...expandArray(mergedLinkOptions, targetEnv, "linkOptions")];
+			const exportArgs = buildExportFlags(targetType === "archive" ? [] : expandArray(mergedExports, targetEnv, "exports"));
+			const resolvedWasmOptArgs = wasmOptEnabled ? resolveWasmOptArgs(common.wasmOpt, target.wasmOpt, targetEnv) : [];
+			const baseCompileArgs = buildCompileArgs(baseCompileOptions, baseIncludeDirs, baseDefines, targetEnv, rootDir);
+			const groupCompileArgs = sourceGroups.map((group) => {
+				return buildCompileArgs([...baseCompileOptions, ...ensureArray(group === null || group === void 0 ? void 0 : group.options)], [...baseIncludeDirs, ...ensureArray(group === null || group === void 0 ? void 0 : group.includeDirs)], mergeDefines(baseDefines, group === null || group === void 0 ? void 0 : group.defines), targetEnv, rootDir);
+			});
+			const compileSource = async (source, args, groupIndex) => {
+				const objectName = toSafeObjectName(rootDir, source, groupIndex);
+				const outputObject = resolve(targetBuildDir, `${objectName}.o`);
+				const compileArgs = [
+					"-c",
+					source,
+					"-o",
+					outputObject,
+					...args.resolvedOptions,
+					...args.includeArgs,
+					...args.defineArgs
+				];
+				const sourcePath = relative(rootDir, source);
+				logger.info(`Compiling source: ${sourcePath} --> $tmp/${objectName}.o`);
+				logger.debug(`emcc ${compileArgs.join(" ")}`);
+				await runCommandWithEnv(emccCommand, compileArgs, rootDir, buildEnv, emsdkOptions.signal);
+				return outputObject;
+			};
+			const buildObjectsSequential = async () => {
+				const objectFiles = [];
+				for (const source of baseSources) objectFiles.push(await compileSource(source, baseCompileArgs, void 0));
+				for (let index = 0; index < groupSources.length; index += 1) {
+					const sourcesInGroup = groupSources[index];
+					if (!sourcesInGroup) continue;
+					const groupArgs = groupCompileArgs[index];
+					if (!groupArgs) continue;
+					for (const source of sourcesInGroup) objectFiles.push(await compileSource(source, groupArgs, index));
+				}
+				return objectFiles;
+			};
+			const compileJobs = [];
+			for (const source of baseSources) compileJobs.push({
+				source,
+				args: baseCompileArgs,
+				groupIndex: void 0
+			});
+			for (let index = 0; index < groupSources.length; index += 1) {
+				const sourcesInGroup = groupSources[index];
+				if (!sourcesInGroup) continue;
+				const groupArgs = groupCompileArgs[index];
+				if (!groupArgs) continue;
+				for (const source of sourcesInGroup) compileJobs.push({
+					source,
+					args: groupArgs,
+					groupIndex: index
+				});
+			}
+			logger.info(parallel ? `Building target: '${targetName}' [${compileJobs.length} files, in parallel]` : `Building target: '${targetName}' [${compileJobs.length} files]`);
+			const objectFiles = parallel ? await Promise.all(compileJobs.map((job) => compileSource(job.source, job.args, job.groupIndex))) : await buildObjectsSequential();
+			if (targetType === "archive") {
+				if (!emarCommand) throw new Error("emar command is required for archive targets.");
+				logger.info(`Archiving target: ${targetName}.a`);
+				const archiveArgs = [
+					"rcs",
+					resolvedOutFile,
+					...objectFiles
+				];
+				logger.debug(`emar ${archiveArgs.join(" ")}`);
+				await runCommandWithEnv(emarCommand, archiveArgs, rootDir, buildEnv, emsdkOptions.signal);
+			} else {
+				logger.info(`Linking target: ${targetName}.wasm`);
+				const linkArgs = [
+					...objectFiles,
+					"-o",
+					resolvedOutFile,
+					...linkLibDirs.map((dir) => `-L${dir}`),
+					...resolvedLinkOptions,
+					...exportArgs
+				];
+				logger.debug(`emcc ${linkArgs.join(" ")}`);
+				await runCommandWithEnv(emccCommand, linkArgs, rootDir, buildEnv, emsdkOptions.signal);
+				if (wasmOptEnabled) {
+					const wasmOptInput = resolveWasmOptInputFile(resolvedOutFile, resolvedLinkOptions);
+					if (!await pathExists(wasmOptInput)) throw new Error(`wasm-opt enabled but wasm binary not found: ${wasmOptInput}`);
+					const tempOutFile = `${wasmOptInput}.opt`;
+					const wasmOptArgs = [
+						wasmOptInput,
+						"-o",
+						tempOutFile,
+						...resolvedWasmOptArgs
+					];
+					const wasmOptCommand = await getWasmOptCommand();
+					logger.info(`Optimizing target: ${targetName}.wasm`);
+					logger.debug(`wasm-opt ${wasmOptArgs.join(" ")}`);
+					await runCommandWithEnv(wasmOptCommand, wasmOptArgs, rootDir, buildEnv, emsdkOptions.signal);
+					await rm(wasmOptInput, { force: true });
+					await rename(tempOutFile, wasmOptInput);
+				}
+			}
+			outFiles[targetName] = resolvedOutFile;
+		}
+	};
+	try {
+		await buildTargets("archive");
+		await buildTargets("wasm");
+		if (generatedLoaderFile) {
+			const generatedTargets = [];
+			const functionNames = /* @__PURE__ */ new Set();
+			for (const [targetName, target] of targetEntries) {
+				if (resolveTargetType(target.type) !== "wasm") continue;
+				const outFile = outFiles[targetName];
+				if (!outFile) continue;
+				const functionName = `load${toPascalCaseIdentifier(targetName)}Wasm`;
+				if (functionNames.has(functionName)) throw new Error(`Generated loader function name collision: ${functionName}`);
+				functionNames.add(functionName);
+				generatedTargets.push({
+					targetName,
+					functionName,
+					outFile
+				});
+			}
+			const didWrite = await writeTextIfChanged(generatedLoaderFile, buildGeneratedLoaderContent(generatedLoaderFile, generatedTargets));
+			logger.info(didWrite ? `Generated loader: ${relative(rootDir, generatedLoaderFile)}` : `Generated loader unchanged: ${relative(rootDir, generatedLoaderFile)}`);
+			resultGeneratedLoaderFile = generatedLoaderFile;
+		}
+	} finally {
+		if (cleanupBuildDir) await rm(buildRunDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	return {
+		emsdkRoot,
+		outFiles,
+		...resultGeneratedLoaderFile ? { generatedLoaderFile: resultGeneratedLoaderFile } : {}
+	};
+};
+//#endregion
+export { createConsoleLogger as n, prepareEmsdk as r, buildWasm as t };
+
+//# sourceMappingURL=build-BAcPqsVO.js.map