emsdk-env 0.7.0 → 0.9.0

package/dist/{build-Btgi1orl.js → build-BOZTStIM.js}

@@ -1,17 +1,17 @@
 /*!
  * name: emsdk-env
- * version: 0.7.0
+ * version: 0.9.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: ddec7e7cc6c59a23b5c87cbd7f99f44e4da3e4b7
+ * git.commit.hash: 73d7e217903f020ef22daa9289362dcd19bddac1
  */
 
-import { mkdir, access, constants, mkdtemp, rename, rm, readFile } from "fs/promises";
+import { mkdir, access, constants, mkdtemp, rename, rm, writeFile, readFile } from "fs/promises";
 import { homedir, tmpdir } from "os";
 import { glob } from "glob";
-import { join, resolve, isAbsolute, dirname, relative } from "path";
+import { join, resolve, relative, isAbsolute, dirname, parse } from "path";
 import { spawn } from "child_process";
 const __NOOP_HANDLER = () => {
 };
@@ -552,6 +552,11 @@ const DEFAULT_IMPORT_LIB_DIR = "lib";
 const DEFAULT_WASM_BUILD_DIR = join(tmpdir(), "emsdk-env");
 const DEFAULT_EMSDK_TARGET_VERSION = "latest";
 const DEFAULT_WASM_OPT_ARGS = ["-Oz"];
+const DEFAULT_GENERATED_LOADER_OUT_FILE = join(
+  "src",
+  "generated",
+  "wasm-loader.ts"
+);
 let buildSequence = 0;
 const padNumber = (value, length = 2) => String(value).padStart(length, "0");
 const formatTimestamp = (date) => {
@@ -578,9 +583,53 @@ const normalizePrepareOptions = (options) => {
     ...rest
   };
 };
+const 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);
+    const value = entry.slice(index + 1);
+    parsed[key] = value;
+  }
+  return parsed;
+};
+const isDefineMap = (input) => input instanceof Map;
+const normalizeDefineInput = (input) => {
+  if (!input) {
+    return {};
+  }
+  if (Array.isArray(input)) {
+    return parseStringKeyValueInput(input);
+  }
+  if (isDefineMap(input)) {
+    return Object.fromEntries(input);
+  }
+  return { ...input };
+};
+const isLinkDirectiveMap = (input) => input instanceof Map;
+const normalizeLinkDirectiveInput = (input) => {
+  if (!input) {
+    return {};
+  }
+  if (Array.isArray(input)) {
+    return parseStringKeyValueInput(input);
+  }
+  if (isLinkDirectiveMap(input)) {
+    return Object.fromEntries(input);
+  }
+  return { ...input };
+};
 const mergeDefines = (common, target) => ({
-  ...common != null ? common : {},
-  ...target != null ? target : {}
+  ...normalizeDefineInput(common),
+  ...normalizeDefineInput(target)
+});
+const mergeLinkDirectives = (common, target) => ({
+  ...normalizeLinkDirectiveInput(common),
+  ...normalizeLinkDirectiveInput(target)
 });
 const resolveWasmOptEnabled = (common, target) => {
   var _a, _b;
@@ -588,10 +637,62 @@ const resolveWasmOptEnabled = (common, target) => {
 };
 const resolveWasmOptArgs = (common, target, env) => {
   var _a, _b;
-  const commonArgs = (_a = common == null ? void 0 : common.args) != null ? _a : DEFAULT_WASM_OPT_ARGS;
-  const targetArgs = (_b = target == null ? void 0 : target.args) != null ? _b : [];
+  const commonArgs = (_a = common == null ? void 0 : common.options) != null ? _a : DEFAULT_WASM_OPT_ARGS;
+  const targetArgs = (_b = target == null ? void 0 : target.options) != null ? _b : [];
   const mergedArgs = [...commonArgs, ...targetArgs];
-  return expandArray(mergedArgs, env, "wasmOpt.args");
+  return expandArray(mergedArgs, env, "wasmOpt.options");
+};
+const stripOuterQuotes = (value) => {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+};
+const extractWasmBinaryFile = (value) => {
+  if (value.startsWith("WASM_BINARY_FILE=")) {
+    return value.slice("WASM_BINARY_FILE=".length);
+  }
+  const match = value.match(/^(?:-s|--settings)(?:=)?WASM_BINARY_FILE=(.+)$/);
+  if (match) {
+    return match[1];
+  }
+  return void 0;
+};
+const 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 extracted2 = extractWasmBinaryFile(next);
+      if (extracted2) {
+        return stripOuterQuotes(extracted2);
+      }
+    }
+    const extracted = extractWasmBinaryFile(option);
+    if (extracted) {
+      return stripOuterQuotes(extracted);
+    }
+  }
+  return void 0;
+};
+const 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);
 };
 const resolvePath = (rootDir, value) => isAbsolute(value) ? value : resolve(rootDir, value);
 const expandPlaceholders = (value, env, label) => value.replace(/\{([A-Z0-9_]+)\}/g, (_match, key) => {
@@ -613,6 +714,28 @@ const resolveDefines = (defines, env) => {
   }
   return resolved;
 };
+const 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;
+};
+const resolveLinkDirectives = (directives, env) => {
+  const resolved = {};
+  for (const [key, value] of Object.entries(directives)) {
+    resolved[key] = resolveLinkDirectiveValue(
+      value,
+      env,
+      `linkDirectives.${key}`
+    );
+  }
+  return resolved;
+};
 const resolveIncludeDirs = (includeDirs, env, rootDir) => {
   const expanded = expandArray(includeDirs, env, "includeDirs");
   return expanded.map((value) => resolvePath(rootDir, value));
@@ -631,7 +754,18 @@ const resolveSourcesFromPatterns = async (patterns, env, srcDir, label) => {
   sources.sort();
   return sources;
 };
-const buildDefineFlags = (defines) => Object.entries(defines).map(([key, value]) => `-D${key}=${String(value)}`);
+const buildDefineFlags = (defines) => Object.entries(defines).flatMap(
+  ([key, value]) => value === null || value === void 0 ? [`-D${key}`] : [`-D${key}=${String(value)}`]
+);
+const serializeLinkDirectiveValue = (value) => Array.isArray(value) ? JSON.stringify(value) : String(value);
+const 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)}`]
+  );
+};
 const buildExportFlags = (exports$1) => {
   if (exports$1.length === 0) {
     return [];
@@ -684,6 +818,248 @@ const dedupeValues = (values) => {
   }
   return deduped;
 };
+const isSubPath = (parentDir, targetPath) => {
+  const rel = relative(parentDir, targetPath);
+  if (rel === "") {
+    return true;
+  }
+  return !rel.startsWith("..") && !isAbsolute(rel);
+};
+const readTextIfExists = async (filePath) => {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+};
+const writeTextIfChanged = async (filePath, content) => {
+  const existing = await readTextIfExists(filePath);
+  if (existing === content) {
+    return false;
+  }
+  await ensureDirectory(dirname(filePath));
+  await writeFile(filePath, content, "utf8");
+  return true;
+};
+const 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;
+};
+const toRelativeImportSpecifier = (fromFile, toFile) => {
+  const rel = relative(dirname(fromFile), toFile).replace(/\\/g, "/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
+const buildGeneratedLoaderContent = (generatedLoaderFile, targets) => {
+  const targetBlocks = targets.map((target) => {
+    const specifier = JSON.stringify(
+      toRelativeImportSpecifier(generatedLoaderFile, target.outFile)
+    );
+    return `export const ${target.functionName} = async <T extends object>(
+  options?: TargetWasmLoadOptions
+): Promise<WasmInstance<T>> => {
+  const source = options?.url ?? new URL(${specifier}, import.meta.url);
+  return await loadWasm<T>(source, {
+    imports: options?.imports,
+  });
+};`;
+  }).join("\n\n");
+  return `// Generated by emsdk-env. DO NOT EDIT.
+
+export type WasmSource =
+  | string
+  | URL
+  | ArrayBuffer
+  | ArrayBufferView
+  | Response;
+
+export interface WasmLoadOptions {
+  readonly imports?: WebAssembly.Imports;
+}
+
+export interface TargetWasmLoadOptions extends WasmLoadOptions {
+  readonly url?: string | URL;
+}
+
+export interface WasmInstance<T extends object> {
+  readonly exports: T;
+  readonly memory: WebAssembly.Memory;
+  readonly table: WebAssembly.Table | undefined;
+  readonly rawExports: WebAssembly.Exports;
+  readonly module: WebAssembly.Module;
+  readonly instance: WebAssembly.Instance;
+  readonly initialize: (() => unknown) | undefined;
+  readonly start: (() => unknown) | undefined;
+}
+
+const resolveWasmBytes = async (source: WasmSource): Promise<ArrayBuffer> => {
+  if (typeof Response !== 'undefined' && source instanceof Response) {
+    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 (ArrayBuffer.isView(source)) {
+    const view = new Uint8Array(
+      source.buffer,
+      source.byteOffset,
+      source.byteLength
+    );
+    return view.slice().buffer;
+  }
+  return 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;
+};
+
+export const loadWasm = async <T extends object>(
+  source: WasmSource,
+  options?: WasmLoadOptions
+): Promise<WasmInstance<T>> => {
+  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 T,
+    memory: resolveMemory(module, instance, options?.imports),
+    table: resolveTable(module, instance, options?.imports),
+    rawExports: instance.exports,
+    module,
+    instance,
+    initialize,
+    start,
+  };
+};
+
+${targetBlocks}
+`;
+};
 const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const resolvePackageJsonPath = async (startPath, packageName) => {
   let current = dirname(startPath);
@@ -784,6 +1160,42 @@ const resolveImportDirectories = async (rootDir, imports) => {
     libDirs: dedupeValues(libDirs)
   };
 };
+const resolveGeneratedLoaderOutFile = (rootDir, env, generatedLoader) => {
+  var _a;
+  if (!(generatedLoader == null ? void 0 : generatedLoader.enable)) {
+    return void 0;
+  }
+  const rawOutFile = expandPlaceholders(
+    (_a = generatedLoader.outFile) != null ? _a : DEFAULT_GENERATED_LOADER_OUT_FILE,
+    env,
+    "generatedLoader.outFile"
+  );
+  return resolvePath(rootDir, rawOutFile);
+};
+const 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);
+};
+const 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}`
+      );
+    }
+  }
+};
 const buildCompileArgs = (options, includeDirs, defines, env, rootDir) => {
   const resolvedOptions = expandArray(options, env, "options");
   const includeArgs = resolveIncludeDirs(includeDirs, env, rootDir).map(
@@ -866,6 +1278,22 @@ const buildWasm = async (options) => {
   const importIncludeDirs = importDirectories.includeDirs;
   const importLibDirs = importDirectories.libDirs;
   const linkLibDirs = dedupeValues([libDir, ...importLibDirs]);
+  const generatedLoaderFile = resolveGeneratedLoaderOutFile(
+    rootDir,
+    envWithDirs,
+    options.generatedLoader
+  );
+  if (generatedLoaderFile) {
+    const watchDirs = resolveGeneratedLoaderWatchDirs(
+      rootDir,
+      srcDir,
+      commonIncludeDirs,
+      envWithDirs,
+      targetEntries,
+      importIncludeDirs
+    );
+    validateGeneratedLoaderOutFile(generatedLoaderFile, watchDirs);
+  }
   logger.debug(`Detected rootDir: '${rootDir}'`);
   logger.debug(`Detected srcDir: '${srcDir}'`);
   logger.debug(`Detected outDir: '${outDir}'`);
@@ -882,6 +1310,9 @@ const buildWasm = async (options) => {
   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);
@@ -904,6 +1335,7 @@ const buildWasm = async (options) => {
     return wasmOptCommand;
   };
   const outFiles = {};
+  let resultGeneratedLoaderFile;
   const buildTargets = async (expectedType) => {
     var _a2;
     for (const [targetName, target] of targetEntries) {
@@ -917,6 +1349,11 @@ const buildWasm = async (options) => {
             `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}`
@@ -932,6 +1369,7 @@ const buildWasm = async (options) => {
         ...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 = [
@@ -991,7 +1429,12 @@ const buildWasm = async (options) => {
       const targetBuildDir = resolve(buildRunDir, targetName);
       await rm(targetBuildDir, { recursive: true, force: true });
       await ensureDirectory(targetBuildDir);
-      const resolvedLinkOptions = targetType === "archive" ? [] : expandArray(mergedLinkOptions, targetEnv, "linkOptions");
+      const resolvedLinkDirectives = targetType === "archive" ? {} : resolveLinkDirectives(mergedLinkDirectives, targetEnv);
+      const linkDirectiveArgs = buildLinkDirectiveFlags(resolvedLinkDirectives);
+      const resolvedLinkOptions = targetType === "archive" ? [] : [
+        ...linkDirectiveArgs,
+        ...expandArray(mergedLinkOptions, targetEnv, "linkOptions")
+      ];
       const resolvedExports = targetType === "archive" ? [] : expandArray(mergedExports, targetEnv, "exports");
       const exportArgs = buildExportFlags(resolvedExports);
       const resolvedWasmOptArgs = wasmOptEnabled ? resolveWasmOptArgs(common.wasmOpt, target.wasmOpt, targetEnv) : [];
@@ -1003,7 +1446,6 @@ const buildWasm = async (options) => {
         rootDir
       );
       const groupCompileArgs = sourceGroups.map((group) => {
-        var _a3;
         const groupOptions = [
           ...baseCompileOptions,
           ...ensureArray(group == null ? void 0 : group.options)
@@ -1012,7 +1454,7 @@ const buildWasm = async (options) => {
           ...baseIncludeDirs,
           ...ensureArray(group == null ? void 0 : group.includeDirs)
         ];
-        const groupDefines = mergeDefines(baseDefines, (_a3 = group == null ? void 0 : group.defines) != null ? _a3 : {});
+        const groupDefines = mergeDefines(baseDefines, group == null ? void 0 : group.defines);
         return buildCompileArgs(
           groupOptions,
           groupIncludeDirs,
@@ -1129,9 +1571,18 @@ const buildWasm = async (options) => {
           emsdkOptions.signal
         );
         if (wasmOptEnabled) {
-          const tempOutFile = `${resolvedOutFile}.opt`;
-          const wasmOptArgs = [
+          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
@@ -1146,8 +1597,8 @@ const buildWasm = async (options) => {
             buildEnv,
             emsdkOptions.signal
           );
-          await rm(resolvedOutFile, { force: true });
-          await rename(tempOutFile, resolvedOutFile);
+          await rm(wasmOptInput, { force: true });
+          await rename(tempOutFile, wasmOptInput);
         }
       }
       outFiles[targetName] = resolvedOutFile;
@@ -1156,6 +1607,40 @@ const buildWasm = async (options) => {
   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 content = buildGeneratedLoaderContent(
+        generatedLoaderFile,
+        generatedTargets
+      );
+      const didWrite = await writeTextIfChanged(generatedLoaderFile, content);
+      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 });
@@ -1163,7 +1648,8 @@ const buildWasm = async (options) => {
   }
   return {
     emsdkRoot,
-    outFiles
+    outFiles,
+    ...resultGeneratedLoaderFile ? { generatedLoaderFile: resultGeneratedLoaderFile } : {}
   };
 };
 export {
@@ -1171,4 +1657,4 @@ export {
   createConsoleLogger as c,
   prepareEmsdk as p
 };
-//# sourceMappingURL=build-Btgi1orl.js.map
+//# sourceMappingURL=build-BOZTStIM.js.map