emsdk-env 0.2.0 → 0.4.0

package/dist/{build-qp0IEBnb.js → build-oSzNI6Av.js}

@@ -1,17 +1,17 @@
 /*!
  * name: emsdk-env
- * version: 0.2.0
+ * version: 0.4.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: e7a4478d462904c71937847aef2de1f460ffc0d5
+ * git.commit.hash: cd0d8e53bf52b98940dd50343a9d3a39200306bd
  */
 
-import { mkdir, access, constants, mkdtemp, rename, rm } from "fs/promises";
+import { mkdir, access, constants, mkdtemp, rename, rm, readFile } from "fs/promises";
 import { homedir, tmpdir } from "os";
 import { glob } from "glob";
-import { join, resolve, isAbsolute, relative } from "path";
+import { join, resolve, isAbsolute, dirname, relative } from "path";
 import { spawn } from "child_process";
 const __NOOP_HANDLER = () => {
 };
@@ -501,6 +501,22 @@ const resolveEmccCommand = async (env, emsdkRoot) => {
   }
   return "emcc";
 };
+const 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";
+};
 const createConsoleLogger = (prefix) => {
   return {
     debug: (msg) => console.debug(`[${prefix}]: ${msg}`),
@@ -510,7 +526,11 @@ const createConsoleLogger = (prefix) => {
   };
 };
 const DEFAULT_WASM_SRC_DIR = "wasm";
+const DEFAULT_WASM_INCLUDE_DIR = "include";
 const DEFAULT_WASM_OUT_DIR = join("src", "wasm");
+const DEFAULT_WASM_LIB_DIR = "lib";
+const DEFAULT_IMPORT_INCLUDE_DIR = "include";
+const DEFAULT_IMPORT_LIB_DIR = "lib";
 const DEFAULT_WASM_BUILD_DIR = join(tmpdir(), "emsdk-env");
 const DEFAULT_EMSDK_TARGET_VERSION = "latest";
 let buildSequence = 0;
@@ -530,7 +550,8 @@ const createBuildId = () => {
   const seq = String(buildSequence).padStart(4, "0");
   return `${timestamp}_${seq}_${process.pid}`;
 };
-const ensureArray = (value) => value ? [...value] : [];
+const ensureArray = (value) => value != null ? value : [];
+const resolveTargetType = (value) => value != null ? value : "wasm";
 const normalizePrepareOptions = (options) => {
   const { targetVersion, ...rest } = options != null ? options : {};
   return {
@@ -570,9 +591,15 @@ const resolveOutFile = (outFile, env, outDir) => {
   const expanded = expandPlaceholders(outFile, env, "outFile");
   return resolvePath(outDir, expanded);
 };
-const resolveSourcePatterns = (patterns, env, srcDir) => {
-  const expanded = expandArray(patterns, env, "sources");
-  return expanded.map((value) => resolvePath(srcDir, value));
+const resolveSourcesFromPatterns = async (patterns, env, srcDir, label) => {
+  const expanded = expandArray(patterns, env, label);
+  const resolvedPatterns = expanded.map((value) => resolvePath(srcDir, value));
+  const results = await Promise.all(
+    resolvedPatterns.map((pattern) => glob(pattern, { nodir: true }))
+  );
+  const sources = results.flat();
+  sources.sort();
+  return sources;
 };
 const buildDefineFlags = (defines) => Object.entries(defines).map(([key, value]) => `-D${key}=${String(value)}`);
 const buildExportFlags = (exports$1) => {
@@ -586,33 +613,165 @@ const createEnvForBuild = (baseEnv, overrides) => ({
   ...baseEnv,
   ...overrides
 });
-const resolveTargetOutFile = (targetName, targetOutFile, env, outDir) => {
+const resolveTargetOutFile = (targetName, targetOutFile, env, baseDir, extension) => {
   if (targetOutFile) {
-    return resolveOutFile(targetOutFile, env, outDir);
+    return resolveOutFile(targetOutFile, env, baseDir);
   }
-  return resolve(outDir, `${targetName}.wasm`);
+  return resolve(baseDir, `${targetName}.${extension}`);
 };
 const resolveTargetSources = async (targetSources, env, srcDir) => {
   const patterns = targetSources && targetSources.length > 0 ? targetSources : [join(srcDir, "**", "*.c"), join(srcDir, "**", "*.cpp")];
-  const resolvedPatterns = resolveSourcePatterns(patterns, env, srcDir);
-  const results = await Promise.all(
-    resolvedPatterns.map((pattern) => glob(pattern, { nodir: true }))
+  return resolveSourcesFromPatterns(patterns, env, srcDir, "sources");
+};
+const 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}`;
+};
+const 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;
+};
+const 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;
+};
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const 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;
+  }
+};
+const 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}`
+    );
+  }
+};
+const 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 sources = results.flat();
-  sources.sort();
-  return sources;
+  const packageRoot = dirname(packageJsonPath);
+  const packageJson = await loadPackageJson(packageJsonPath, packageName);
+  const emsdkConfigRaw = packageJson["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 : DEFAULT_IMPORT_INCLUDE_DIR;
+  const libRel = libRaw != null ? 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
+  };
+};
+const resolveImportDirectories = async (rootDir, imports) => {
+  if (imports.length === 0) {
+    return { includeDirs: [], libDirs: [] };
+  }
+  const moduleApi = await import("./__vite-browser-external-2Ng8QIWW.js");
+  const resolver = moduleApi.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)
+  };
+};
+const buildCompileArgs = (options, includeDirs, defines, env, rootDir) => {
+  const resolvedOptions = expandArray(options, env, "options");
+  const includeArgs = resolveIncludeDirs(includeDirs, env, rootDir).map(
+    (dir) => `-I${dir}`
+  );
+  const defineArgs = buildDefineFlags(resolveDefines(defines, env));
+  return { resolvedOptions, includeArgs, defineArgs };
 };
-const toSafeObjectName = (rootDir, sourcePath) => relative(rootDir, sourcePath).replace(/[\\/]/g, "_").replace(/[^A-Za-z0-9._-]/g, "_");
 const buildWasm = async (options) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   if (!options) {
     throw new TypeError("options must be provided.");
   }
   if (!options.rule || !options.rule.targets) {
     throw new TypeError("rule targets must be provided.");
   }
-  const targets = Object.entries(options.rule.targets);
-  if (targets.length === 0) {
+  const targetEntries = Object.entries(options.rule.targets);
+  if (targetEntries.length === 0) {
     throw new TypeError("rule targets must not be empty.");
   }
   const logger = (_a = options.logger) != null ? _a : createConsoleLogger("emsdk-env");
@@ -629,56 +788,118 @@ const buildWasm = async (options) => {
     baseEnv,
     "srcDir"
   );
+  const rawIncludeDir = expandPlaceholders(
+    (_d = options.includeDir) != null ? _d : DEFAULT_WASM_INCLUDE_DIR,
+    baseEnv,
+    "includeDir"
+  );
   const rawOutDir = expandPlaceholders(
-    (_d = options.outDir) != null ? _d : DEFAULT_WASM_OUT_DIR,
+    (_e = options.outDir) != null ? _e : DEFAULT_WASM_OUT_DIR,
     baseEnv,
     "outDir"
   );
+  const rawLibDir = expandPlaceholders(
+    (_f = options.libDir) != null ? _f : DEFAULT_WASM_LIB_DIR,
+    baseEnv,
+    "libDir"
+  );
   const rawBuildDir = expandPlaceholders(
-    (_e = options.buildDir) != null ? _e : DEFAULT_WASM_BUILD_DIR,
+    (_g = options.buildDir) != null ? _g : 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 = (_f = options.cleanupBuildDir) != null ? _f : true;
-  const parallel = (_g = options.parallel) != null ? _g : true;
+  const cleanupBuildDir = (_h = options.cleanupBuildDir) != null ? _h : true;
+  const parallel = (_i = options.parallel) != null ? _i : 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 = (_h = options.rule.common) != null ? _h : {};
+  const common = (_j = options.rule.common) != null ? _j : {};
+  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]);
+  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(",")}]`
+  );
   await ensureDirectory(outDir);
+  await ensureDirectory(libDir);
   await ensureDirectory(buildDir);
   await rm(buildRunDir, { recursive: true, force: true });
   await ensureDirectory(buildRunDir);
+  const hasArchiveTargets = targetEntries.some(
+    ([, target]) => resolveTargetType(target.type) === "archive"
+  );
+  const emarCommand = hasArchiveTargets ? await resolveEmarCommand(envWithDirs, emsdkRoot) : void 0;
+  if (emarCommand) {
+    logger.debug(`Detected emarCommand: '${emarCommand}'`);
+  }
   const outFiles = {};
-  try {
-    for (const [targetName, target] of targets) {
-      const mergedOptions = [
-        ...ensureArray(common.options),
-        ...ensureArray(target.options)
-      ];
-      const mergedLinkOptions = [
+  const buildTargets = async (expectedType) => {
+    var _a2;
+    for (const [targetName, target] of targetEntries) {
+      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.exports !== void 0) {
+          throw new Error(
+            `exports is not supported for archive target: ${targetName}`
+          );
+        }
+      }
+      const mergedLinkOptions = targetType === "archive" ? [] : [
         ...ensureArray(common.linkOptions),
         ...ensureArray(target.linkOptions)
       ];
-      const mergedExports = [
-        ...ensureArray(common.exports),
-        ...ensureArray(target.exports)
+      const mergedExports = targetType === "archive" ? [] : [...ensureArray(common.exports), ...ensureArray(target.exports)];
+      const baseCompileOptions = [
+        ...ensureArray(common.options),
+        ...ensureArray(target.options)
       ];
-      const mergedIncludeDirs = [
-        ...ensureArray(common.includeDirs),
-        ...ensureArray(target.includeDirs)
+      const baseIncludeDirs = [
+        ...ensureArray(commonIncludeDirs),
+        ...ensureArray(target.includeDirs),
+        ...importIncludeDirs
       ];
-      const mergedDefines = mergeDefines(common.defines, target.defines);
+      const baseDefines = mergeDefines(common.defines, target.defines);
+      const sourceGroups = (_a2 = target.sourceGroups) != null ? _a2 : [];
       const targetEnv = {
         ...envWithDirs,
         TARGET_NAME: targetName
@@ -688,52 +909,90 @@ const buildWasm = async (options) => {
         targetName,
         target.outFile,
         targetEnv,
-        outDir
+        targetType === "archive" ? libDir : outDir,
+        targetType === "archive" ? "a" : "wasm"
       );
       const sources = await resolveTargetSources(
         target.sources,
         targetEnv,
         srcDir
       );
-      if (sources.length === 0) {
+      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 resolved = await resolveSourcesFromPatterns(
+          group.sources,
+          targetEnv,
+          srcDir,
+          `sourceGroups[${index}].sources`
+        );
+        const deduped = dedupeSources(resolved);
+        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 resolvedOptions = expandArray(mergedOptions, targetEnv, "options");
-      const resolvedLinkOptions = expandArray(
-        mergedLinkOptions,
-        targetEnv,
-        "linkOptions"
-      );
-      const resolvedExports = expandArray(mergedExports, targetEnv, "exports");
+      const resolvedLinkOptions = targetType === "archive" ? [] : expandArray(mergedLinkOptions, targetEnv, "linkOptions");
+      const resolvedExports = targetType === "archive" ? [] : expandArray(mergedExports, targetEnv, "exports");
       const exportArgs = buildExportFlags(resolvedExports);
-      const includeArgs = resolveIncludeDirs(
-        mergedIncludeDirs,
+      const baseCompileArgs = buildCompileArgs(
+        baseCompileOptions,
+        baseIncludeDirs,
+        baseDefines,
         targetEnv,
         rootDir
-      ).map((dir) => `-I${dir}`);
-      const defineArgs = buildDefineFlags(
-        resolveDefines(mergedDefines, targetEnv)
       );
-      logger.info(`Compiling target: ${targetName}`);
-      const compileSource = async (source) => {
-        const objectName = toSafeObjectName(rootDir, source);
+      const groupCompileArgs = sourceGroups.map((group) => {
+        var _a3;
+        const groupOptions = [
+          ...baseCompileOptions,
+          ...ensureArray(group == null ? void 0 : group.options)
+        ];
+        const groupIncludeDirs = [
+          ...baseIncludeDirs,
+          ...ensureArray(group == null ? void 0 : group.includeDirs)
+        ];
+        const groupDefines = mergeDefines(baseDefines, (_a3 = group == null ? void 0 : group.defines) != null ? _a3 : {});
+        return buildCompileArgs(
+          groupOptions,
+          groupIncludeDirs,
+          groupDefines,
+          targetEnv,
+          rootDir
+        );
+      });
+      const compileSource = async (source, args, groupIndex) => {
+        const objectName = toSafeObjectName(rootDir, source, groupIndex);
         const outputObject = resolve(targetBuildDir, `${objectName}.o`);
-        const args = [
+        const compileArgs = [
           "-c",
           source,
           "-o",
           outputObject,
-          ...resolvedOptions,
-          ...includeArgs,
-          ...defineArgs
+          ...args.resolvedOptions,
+          ...args.includeArgs,
+          ...args.defineArgs
         ];
-        logger.debug(`emcc ${args.join(" ")}`);
+        const sourcePath = relative(rootDir, source);
+        logger.info(`Compiling source: ${sourcePath} --> $tmp/${objectName}.o`);
+        logger.debug(`emcc ${compileArgs.join(" ")}`);
         await runCommandWithEnv(
           emccCommand,
-          args,
+          compileArgs,
           rootDir,
           buildEnv,
           emsdkOptions.signal
@@ -742,30 +1001,94 @@ const buildWasm = async (options) => {
       };
       const buildObjectsSequential = async () => {
         const objectFiles2 = [];
-        for (const source of sources) {
-          objectFiles2.push(await compileSource(source));
+        for (const source of baseSources) {
+          objectFiles2.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) {
+            objectFiles2.push(await compileSource(source, groupArgs, index));
+          }
         }
         return objectFiles2;
       };
-      const objectFiles = parallel ? await Promise.all(sources.map((source) => compileSource(source))) : await buildObjectsSequential();
-      logger.info(`Linking target: ${targetName}`);
-      const linkArgs = [
-        ...objectFiles,
-        "-o",
-        resolvedOutFile,
-        ...resolvedLinkOptions,
-        ...exportArgs
-      ];
-      logger.debug(`emcc ${linkArgs.join(" ")}`);
-      await runCommandWithEnv(
-        emccCommand,
-        linkArgs,
-        rootDir,
-        buildEnv,
-        emsdkOptions.signal
+      const compileJobs = [];
+      for (const source of baseSources) {
+        compileJobs.push({
+          source,
+          args: baseCompileArgs,
+          groupIndex: void 0
+        });
+      }
+      logger.info(
+        parallel ? `Building target: '${targetName}' [${compileJobs.length} files, in parallel]` : `Building target: '${targetName}' [${compileJobs.length} files]`
       );
+      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 });
+        }
+      }
+      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
+        );
+      }
       outFiles[targetName] = resolvedOutFile;
     }
+  };
+  try {
+    await buildTargets("archive");
+    await buildTargets("wasm");
   } finally {
     if (cleanupBuildDir) {
       await rm(buildRunDir, { recursive: true, force: true });
@@ -780,4 +1103,4 @@ export {
   buildWasm as b,
   prepareEmsdk as p
 };
-//# sourceMappingURL=build-qp0IEBnb.js.map
+//# sourceMappingURL=build-oSzNI6Av.js.map