@bytecodealliance/jco 1.10.2 → 1.11.0

package/src/cmd/transpile.js

@@ -1,43 +1,62 @@
-import { $init, generate, generateTypes } from '../../obj/js-component-bindgen-component.js';
-import { writeFile } from 'node:fs/promises';
+import { platform } from 'node:process';
+import { writeFile, stat } from 'node:fs/promises';
 import { mkdir } from 'node:fs/promises';
 import { dirname, extname, basename, resolve } from 'node:path';
+
 import c from 'chalk-template';
-import { readFile, sizeStr, table, spawnIOTmp, setShowSpinner, getShowSpinner } from '../common.js';
-import { optimizeComponent } from './opt.js';
 import { minify } from 'terser';
 import { fileURLToPath } from 'url';
-import { $init as wasmToolsInit, tools } from "../../obj/wasm-tools.js";
+
+import {
+    $init,
+    generate,
+    generateTypes,
+} from '../../obj/js-component-bindgen-component.js';
+import {
+    readFile,
+    sizeStr,
+    table,
+    spawnIOTmp,
+    setShowSpinner,
+    getShowSpinner,
+} from '../common.js';
+import { optimizeComponent } from './opt.js';
+import { $init as wasmToolsInit, tools } from '../../obj/wasm-tools.js';
 const { componentEmbed, componentNew } = tools;
+
 import ora from '#ora';
-import { platform } from 'node:process';
 
 const isWindows = platform === 'win32';
 
 const ASYNC_WASI_IMPORTS = [
-  "wasi:io/poll#poll",
-  "wasi:io/poll#[method]pollable.block",
-  "wasi:io/streams#[method]input-stream.blocking-read",
-  "wasi:io/streams#[method]input-stream.blocking-skip",
-  "wasi:io/streams#[method]output-stream.blocking-flush",
-  "wasi:io/streams#[method]output-stream.blocking-write-and-flush",
-  "wasi:io/streams#[method]output-stream.blocking-write-zeroes-and-flush",
-  "wasi:io/streams#[method]output-stream.blocking-splice",
+    'wasi:io/poll#poll',
+    'wasi:io/poll#[method]pollable.block',
+    'wasi:io/streams#[method]input-stream.blocking-read',
+    'wasi:io/streams#[method]input-stream.blocking-skip',
+    'wasi:io/streams#[method]output-stream.blocking-flush',
+    'wasi:io/streams#[method]output-stream.blocking-write-and-flush',
+    'wasi:io/streams#[method]output-stream.blocking-write-zeroes-and-flush',
+    'wasi:io/streams#[method]output-stream.blocking-splice',
 ];
 
 const ASYNC_WASI_EXPORTS = [
-  "wasi:cli/run#run",
-  "wasi:http/incoming-handler#handle",
+    'wasi:cli/run#run',
+    'wasi:http/incoming-handler#handle',
 ];
 
-export async function types (witPath, opts) {
-  const files = await typesComponent(witPath, opts);
-  await writeFiles(files, opts.quiet ? false : 'Generated Type Files');
+export async function types(witPath, opts) {
+    const files = await typesComponent(witPath, opts);
+    await writeFiles(files, opts.quiet ? false : 'Generated Type Files');
 }
 
-export async function guestTypes (witPath, opts) {
-  const files = await typesComponent(witPath, { ...opts, guest: true });
-  await writeFiles(files, opts.quiet ? false : 'Generated Guest Typescript Definition Files (.d.ts)');
+export async function guestTypes(witPath, opts) {
+    const files = await typesComponent(witPath, { ...opts, guest: true });
+    await writeFiles(
+        files,
+        opts.quiet
+            ? false
+            : 'Generated Guest Typescript Definition Files (.d.ts)'
+    );
 }
 
 /**
@@ -56,114 +75,165 @@ export async function guestTypes (witPath, opts) {
  * }} opts
  * @returns {Promise<{ [filename: string]: Uint8Array }>}
  */
-export async function typesComponent (witPath, opts) {
-  await $init;
-  const name = opts.name || (opts.worldName
-    ? opts.worldName.split(':').pop().split('/').pop()
-    : basename(witPath.slice(0, -extname(witPath).length || Infinity)));
-  let instantiation;
-  if (opts.instantiation) {
-    instantiation = { tag: opts.instantiation };
-  }
-  let outDir = (opts.outDir ?? '').replace(/\\/g, '/');
-  if (!outDir.endsWith('/') && outDir !== '')
-    outDir += '/';
-
-  let features = null;
-  if (opts.allFeatures) {
-    features = { tag: 'all' };
-  } else if (Array.isArray(opts.feature)) {
-    features = { tag: 'list', val: opts.feature };
-  }
-
-  if (opts.asyncWasiImports)
-    opts.asyncImports = ASYNC_WASI_IMPORTS.concat(opts.asyncImports || []);
-  if (opts.asyncWasiExports)
-    opts.asyncExports = ASYNC_WASI_EXPORTS.concat(opts.asyncExports || []);
-
-  const asyncMode = !opts.asyncMode || opts.asyncMode === 'sync' ?
-    null :
-    {
-      tag: opts.asyncMode,
-      val: {
-        imports: opts.asyncImports || [],
-        exports: opts.asyncExports || [],
-      },
-    };
-
-  return Object.fromEntries(generateTypes(name, {
-    wit: { tag: 'path', val: (isWindows ? '//?/' : '') + resolve(witPath) },
-    instantiation,
-    tlaCompat: opts.tlaCompat ?? false,
-    world: opts.worldName,
-    features,
-    guest: opts.guest ?? false,
-    asyncMode,
-  }).map(([name, file]) => [`${outDir}${name}`, file]));
+export async function typesComponent(witPath, opts) {
+    await $init;
+    const name =
+        opts.name ||
+        (opts.worldName
+            ? opts.worldName.split(':').pop().split('/').pop()
+            : basename(witPath.slice(0, -extname(witPath).length || Infinity)));
+    let instantiation;
+    if (opts.instantiation) {
+        instantiation = { tag: opts.instantiation };
+    }
+    let outDir = (opts.outDir ?? '').replace(/\\/g, '/');
+    if (!outDir.endsWith('/') && outDir !== '') outDir += '/';
+
+    let features = null;
+    if (opts.allFeatures) {
+        features = { tag: 'all' };
+    } else if (Array.isArray(opts.feature)) {
+        features = { tag: 'list', val: opts.feature };
+    }
+
+    if (opts.asyncWasiImports)
+        opts.asyncImports = ASYNC_WASI_IMPORTS.concat(opts.asyncImports || []);
+    if (opts.asyncWasiExports)
+        opts.asyncExports = ASYNC_WASI_EXPORTS.concat(opts.asyncExports || []);
+
+    const asyncMode =
+        !opts.asyncMode || opts.asyncMode === 'sync'
+            ? null
+            : {
+                  tag: opts.asyncMode,
+                  val: {
+                      imports: opts.asyncImports || [],
+                      exports: opts.asyncExports || [],
+                  },
+              };
+
+    let types;
+    const absWitPath = resolve(witPath);
+    try {
+        types = generateTypes(name, {
+            wit: { tag: 'path', val: (isWindows ? '//?/' : '') + absWitPath },
+            instantiation,
+            tlaCompat: opts.tlaCompat ?? false,
+            world: opts.worldName,
+            features,
+            guest: opts.guest ?? false,
+            asyncMode,
+        }).map(([name, file]) => [`${outDir}${name}`, file]);
+    } catch (err) {
+        if (err.toString().includes('does not match previous package name')) {
+            const hint = await printWITLayoutHint(absWitPath);
+            if (err.message) {
+                err.message += `\n${hint}`;
+            }
+            throw err;
+        }
+        throw err;
+    }
+
+    return Object.fromEntries(types);
+}
+
+/**
+ * Print a hint about WIT folder layout
+ *
+ * @param {(string, any) => void} consoleFn
+ */
+async function printWITLayoutHint(witPath) {
+    const pathMeta = await stat(witPath);
+    let output = '\n';
+    if (!pathMeta.isFile() && !pathMeta.isDirectory()) {
+        output += c`{yellow.bold warning} The supplited WIT path [${witPath}] is neither a file or directory.\n`;
+        return output;
+    }
+    const ftype = pathMeta.isDirectory() ? 'directory' : 'file';
+    output += c`{yellow.bold warning} Your WIT ${ftype} [${witPath}] may be laid out incorrectly\n`;
+    output += c`{yellow.bold warning} Keep in mind the following rules:\n`;
+    output += c`{yellow.bold warning}     - Top level WIT files are in the same package (i.e. "ns:pkg" in "wit/*.wit")\n`;
+    output += c`{yellow.bold warning}     - All package dependencies should be in "wit/deps" (i.e. "some:dep" in "wit/deps/some-dep.wit"\n`;
+    return output;
 }
 
 async function writeFiles(files, summaryTitle) {
-  await Promise.all(Object.entries(files).map(async ([name, file]) => {
-    await mkdir(dirname(name), { recursive: true });
-    await writeFile(name, file);
-  }));
-  if (!summaryTitle)
-    return;
-  console.log(c`
+    await Promise.all(
+        Object.entries(files).map(async ([name, file]) => {
+            await mkdir(dirname(name), { recursive: true });
+            await writeFile(name, file);
+        })
+    );
+    if (!summaryTitle) return;
+    console.log(c`
   {bold ${summaryTitle}:}
 
-${table(Object.entries(files).map(([name, source]) => [
-    c` - {italic ${name}}  `,
-    c`{black.italic ${sizeStr(source.length)}}`
-  ]))}`);
+${table(
+    Object.entries(files).map(([name, source]) => [
+        c` - {italic ${name}}  `,
+        c`{black.italic ${sizeStr(source.length)}}`,
+    ])
+)}`);
 }
 
-export async function transpile (componentPath, opts, program) {
-  const varIdx = program?.parent.rawArgs.indexOf('--');
-  if (varIdx !== undefined && varIdx !== -1)
-    opts.optArgs = program.parent.rawArgs.slice(varIdx + 1);
-
-  let component;
-  if (!opts.stub) {
-    component = await readFile(componentPath);
-  } else {
-    await wasmToolsInit;
-    component = componentNew(componentEmbed({
-      dummy: true,
-      witPath: (isWindows ? '//?/' : '') + resolve(componentPath)
-    }), []);
-  }
-
-  if (!opts.quiet)
-    setShowSpinner(true);
-  if (!opts.name)
-    opts.name = basename(componentPath.slice(0, -extname(componentPath).length || Infinity));
-  if (opts.map)
-    opts.map = Object.fromEntries(opts.map.map(mapping => mapping.split('=')));
-
-  if (opts.asyncWasiImports)
-    opts.asyncImports = ASYNC_WASI_IMPORTS.concat(opts.asyncImports || []);
-  if (opts.asyncWasiExports)
-    opts.asyncExports = ASYNC_WASI_EXPORTS.concat(opts.asyncExports || []);
-
-  const { files } = await transpileComponent(component, opts);
-  await writeFiles(files, opts.quiet ? false : 'Transpiled JS Component Files');
+export async function transpile(componentPath, opts, program) {
+    const varIdx = program?.parent.rawArgs.indexOf('--');
+    if (varIdx !== undefined && varIdx !== -1)
+        opts.optArgs = program.parent.rawArgs.slice(varIdx + 1);
+
+    let component;
+    if (!opts.stub) {
+        component = await readFile(componentPath);
+    } else {
+        await wasmToolsInit;
+        component = componentNew(
+            componentEmbed({
+                dummy: true,
+                witPath: (isWindows ? '//?/' : '') + resolve(componentPath),
+            }),
+            []
+        );
+    }
+
+    if (!opts.quiet) setShowSpinner(true);
+    if (!opts.name)
+        opts.name = basename(
+            componentPath.slice(0, -extname(componentPath).length || Infinity)
+        );
+    if (opts.map)
+        opts.map = Object.fromEntries(
+            opts.map.map((mapping) => mapping.split('='))
+        );
+
+    if (opts.asyncWasiImports)
+        opts.asyncImports = ASYNC_WASI_IMPORTS.concat(opts.asyncImports || []);
+    if (opts.asyncWasiExports)
+        opts.asyncExports = ASYNC_WASI_EXPORTS.concat(opts.asyncExports || []);
+
+    const { files } = await transpileComponent(component, opts);
+    await writeFiles(
+        files,
+        opts.quiet ? false : 'Transpiled JS Component Files'
+    );
 }
 
 /**
  * @param {Uint8Array} source
  * @returns {Promise<Uint8Array>}
  */
-async function wasm2Js (source) {
-  const wasm2jsPath = fileURLToPath(import.meta.resolve('binaryen/bin/wasm2js'));
-
-  try {
-    return await spawnIOTmp(wasm2jsPath, source, ['-Oz', '-o']);
-  } catch (e) {
-    if (e.toString().includes('BasicBlock requested'))
-      return wasm2Js(source);
-    throw e;
-  }
+async function wasm2Js(source) {
+    const wasm2jsPath = fileURLToPath(
+        import.meta.resolve('binaryen/bin/wasm2js')
+    );
+
+    try {
+        return await spawnIOTmp(wasm2jsPath, source, ['-Oz', '-o']);
+    } catch (e) {
+        if (e.toString().includes('BasicBlock requested'))
+            return wasm2Js(source);
+        throw e;
+    }
 }
 
 /**
@@ -193,178 +263,198 @@ async function wasm2Js (source) {
  * }} opts
  * @returns {Promise<{ files: { [filename: string]: Uint8Array }, imports: string[], exports: [string, 'function' | 'instance'][] }>}
  */
-export async function transpileComponent (component, opts = {}) {
-  await $init;
-  if (opts.instantiation) opts.wasiShim = false;
-
-  let spinner;
-  const showSpinner = getShowSpinner();
-
-  if (opts.optimize) {
-    if (showSpinner) setShowSpinner(true);
-    ({ component } = await optimizeComponent(component, opts));
-  }
-
-  if (opts.wasiShim !== false) {
-    opts.map = Object.assign({
-      'wasi:cli/*': '@bytecodealliance/preview2-shim/cli#*',
-      'wasi:clocks/*': '@bytecodealliance/preview2-shim/clocks#*',
-      'wasi:filesystem/*': '@bytecodealliance/preview2-shim/filesystem#*',
-      'wasi:http/*': '@bytecodealliance/preview2-shim/http#*',
-      'wasi:io/*': '@bytecodealliance/preview2-shim/io#*',
-      'wasi:random/*': '@bytecodealliance/preview2-shim/random#*',
-      'wasi:sockets/*': '@bytecodealliance/preview2-shim/sockets#*',
-    }, opts.map || {});
-  }
-
-  let instantiation = null;
-
-  // Let's define `instantiation` from `--instantiation` if it's present.
-  if (opts.instantiation) {
-    instantiation = { tag: opts.instantiation };
-  }
-  // Otherwise, if `--js` is present, an `instantiate` function is required.
-  else if (opts.js) {
-    instantiation = { tag: 'async' };
-  }
-
-  const asyncMode = !opts.asyncMode || opts.asyncMode === 'sync' ?
-    null :
-    {
-      tag: opts.asyncMode,
-      val: {
-        imports: opts.asyncImports || [],
-        exports: opts.asyncExports || [],
-      },
-    };
-
-  let { files, imports, exports } = generate(component, {
-    name: opts.name ?? 'component',
-    map: Object.entries(opts.map ?? {}),
-    instantiation,
-    asyncMode,
-    importBindings: opts.importBindings ? { tag: opts.importBindings } : null,
-    validLiftingOptimization: opts.validLiftingOptimization ?? false,
-    tracing: opts.tracing ?? false,
-    noNodejsCompat: opts.nodejsCompat === false,
-    noTypescript: opts.typescript === false,
-    tlaCompat: opts.tlaCompat ?? false,
-    base64Cutoff: opts.js ? 0 : opts.base64Cutoff ?? 5000,
-    noNamespacedExports: opts.namespacedExports === false,
-    multiMemory: opts.multiMemory === true,
-    idlImports: opts.experimentalIdlImports === true,
-  });
-
-  let outDir = (opts.outDir ?? '').replace(/\\/g, '/');
-  if (!outDir.endsWith('/') && outDir !== '')
-    outDir += '/';
-  files = files.map(([name, source]) => [`${outDir}${name}`, source]);
-
-  const jsFile = files.find(([name]) => name.endsWith('.js'));
-
-  // Generate code for the `--js` option.
-  //
-  // `--js` can be called with or without `--instantiation`. The generated code
-  // isn't exactly the same!
-  //
-  // `--js` needs an `instantiate` function to work, so it might look like
-  // `--instantiation` is always implied, but actually no. It is correct
-  // that when `--js` is present, an `instantiate` function _is_ generated,
-  // but it doesn't mean that we expect the function to be used, it's simply
-  // not exported, plus `instantiate` is automatically called (if `--tla-compat`
-  // is `false`). When `--instantiation` is missing, functions are exported
-  // with the `export` directive, and imports are imported with the `import`
-  // directive. When `--instantiation` is present, there is no `export` and no
-  // `import`: only a single exported `instantiate` function.
-  //
-  // Basically, we get this:
-  //
-  // * `--js` only:
-  //   * `instantiate` is renamed to `_instantiate`,
-  //   * A new `instantiate` function is created, that calls `_instantiate` with
-  //     the correct imports (which are ASM.js code) and returns the exports,
-  //   * A new `$init` function is created, that calls `instantiate` and maps
-  //     the returned exports to their respective trampolines,
-  //   * Trampolines are exported,
-  //   * `$init` is called automatically.
-  //
-  // * `--js` with `--tla-compat`:
-  //   * Same as with `--js` only, except that `$init` is exported instead of
-  //     being called immediately.
-  //
-  // * `--js` with `--instantiation[=async]`:
-  //   * `instantiate` is renamed to `_instantiate`,
-  //   * A new `instantiate` function is created, that calls `_instantiate` with
-  //     the correct imports (which are ASM.js code) and returns the exports,
-  //   * `instantiate` is exported.
-  //
-  // * `--js` with `--instantiation=sync`:
-  //   * Same as `--js` with `--instantiation[=async]`, except that
-  //     `_instantiate` and `instantiate` are non-async.
-  //
-  // Be careful with the variables: `opts.instantiation` reflects the presence
-  // or the absence of the `--instantiation` flag, whilst `instantiation`
-  // reflects how the `instantiate` function must be generated. We also use
-  // `instantiation` to know whether the generated code must be async or
-  // non-async.
-  if (opts.js) {
-    const withInstantiation = opts.instantiation !== undefined;
-    const async_ = instantiation.tag == 'async' ? 'async ' : '';
-    const await_ = instantiation.tag == 'async' ? 'await ' : '';
-
-    // Format the previously generated code.
-    const source = Buffer.from(jsFile[1]).toString('utf8')
-      // update imports manging to match emscripten asm
-      .replace(/exports(\d+)\['([^']+)']/g, (_, i, s) => `exports${i}['${asmMangle(s)}']`)
-      .replace(/export (async )?function instantiate/, '$1function _instantiate') ;
-
-    // Collect all Wasm files.
-    const wasmFiles = files.filter(([name]) => name.endsWith('.wasm'));
-    files = files.filter(([name]) => !name.endsWith('.wasm'));
-
-    // Configure the spinner.
-    let completed = 0;
-    const spinnerText = () => c`{cyan ${completed} / ${wasmFiles.length}} Running Binaryen wasm2js on Wasm core modules (this takes a while)...\n`;
-    if (showSpinner) {
-      spinner = ora({
-        color: 'cyan',
-        spinner: 'bouncingBar'
-      }).start();
-      spinner.text = spinnerText();
+export async function transpileComponent(component, opts = {}) {
+    await $init;
+    if (opts.instantiation) opts.wasiShim = false;
+
+    let spinner;
+    const showSpinner = getShowSpinner();
+
+    if (opts.optimize) {
+        if (showSpinner) setShowSpinner(true);
+        ({ component } = await optimizeComponent(component, opts));
     }
 
-    // Compile all Wasm modules into ASM.js codes.
-    try {
-      const asmFiles = await Promise.all(wasmFiles.map(async ([, source]) => {
-        const output = (await wasm2Js(source)).toString('utf8');
-        if (spinner) {
-          completed++;
-          spinner.text = spinnerText();
+    if (opts.wasiShim !== false) {
+        opts.map = Object.assign(
+            {
+                'wasi:cli/*': '@bytecodealliance/preview2-shim/cli#*',
+                'wasi:clocks/*': '@bytecodealliance/preview2-shim/clocks#*',
+                'wasi:filesystem/*':
+                    '@bytecodealliance/preview2-shim/filesystem#*',
+                'wasi:http/*': '@bytecodealliance/preview2-shim/http#*',
+                'wasi:io/*': '@bytecodealliance/preview2-shim/io#*',
+                'wasi:random/*': '@bytecodealliance/preview2-shim/random#*',
+                'wasi:sockets/*': '@bytecodealliance/preview2-shim/sockets#*',
+            },
+            opts.map || {}
+        );
+    }
+
+    let instantiation = null;
+
+    // Let's define `instantiation` from `--instantiation` if it's present.
+    if (opts.instantiation) {
+        instantiation = { tag: opts.instantiation };
+    }
+    // Otherwise, if `--js` is present, an `instantiate` function is required.
+    else if (opts.js) {
+        instantiation = { tag: 'async' };
+    }
+
+    const asyncMode =
+        !opts.asyncMode || opts.asyncMode === 'sync'
+            ? null
+            : {
+                  tag: opts.asyncMode,
+                  val: {
+                      imports: opts.asyncImports || [],
+                      exports: opts.asyncExports || [],
+                  },
+              };
+
+    let { files, imports, exports } = generate(component, {
+        name: opts.name ?? 'component',
+        map: Object.entries(opts.map ?? {}),
+        instantiation,
+        asyncMode,
+        importBindings: opts.importBindings
+            ? { tag: opts.importBindings }
+            : null,
+        validLiftingOptimization: opts.validLiftingOptimization ?? false,
+        tracing: opts.tracing ?? false,
+        noNodejsCompat: opts.nodejsCompat === false,
+        noTypescript: opts.typescript === false,
+        tlaCompat: opts.tlaCompat ?? false,
+        base64Cutoff: opts.js ? 0 : (opts.base64Cutoff ?? 5000),
+        noNamespacedExports: opts.namespacedExports === false,
+        multiMemory: opts.multiMemory === true,
+        idlImports: opts.experimentalIdlImports === true,
+    });
+
+    let outDir = (opts.outDir ?? '').replace(/\\/g, '/');
+    if (!outDir.endsWith('/') && outDir !== '') outDir += '/';
+    files = files.map(([name, source]) => [`${outDir}${name}`, source]);
+
+    const jsFile = files.find(([name]) => name.endsWith('.js'));
+
+    // Generate code for the `--js` option.
+    //
+    // `--js` can be called with or without `--instantiation`. The generated code
+    // isn't exactly the same!
+    //
+    // `--js` needs an `instantiate` function to work, so it might look like
+    // `--instantiation` is always implied, but actually no. It is correct
+    // that when `--js` is present, an `instantiate` function _is_ generated,
+    // but it doesn't mean that we expect the function to be used, it's simply
+    // not exported, plus `instantiate` is automatically called (if `--tla-compat`
+    // is `false`). When `--instantiation` is missing, functions are exported
+    // with the `export` directive, and imports are imported with the `import`
+    // directive. When `--instantiation` is present, there is no `export` and no
+    // `import`: only a single exported `instantiate` function.
+    //
+    // Basically, we get this:
+    //
+    // * `--js` only:
+    //   * `instantiate` is renamed to `_instantiate`,
+    //   * A new `instantiate` function is created, that calls `_instantiate` with
+    //     the correct imports (which are ASM.js code) and returns the exports,
+    //   * A new `$init` function is created, that calls `instantiate` and maps
+    //     the returned exports to their respective trampolines,
+    //   * Trampolines are exported,
+    //   * `$init` is called automatically.
+    //
+    // * `--js` with `--tla-compat`:
+    //   * Same as with `--js` only, except that `$init` is exported instead of
+    //     being called immediately.
+    //
+    // * `--js` with `--instantiation[=async]`:
+    //   * `instantiate` is renamed to `_instantiate`,
+    //   * A new `instantiate` function is created, that calls `_instantiate` with
+    //     the correct imports (which are ASM.js code) and returns the exports,
+    //   * `instantiate` is exported.
+    //
+    // * `--js` with `--instantiation=sync`:
+    //   * Same as `--js` with `--instantiation[=async]`, except that
+    //     `_instantiate` and `instantiate` are non-async.
+    //
+    // Be careful with the variables: `opts.instantiation` reflects the presence
+    // or the absence of the `--instantiation` flag, whilst `instantiation`
+    // reflects how the `instantiate` function must be generated. We also use
+    // `instantiation` to know whether the generated code must be async or
+    // non-async.
+    if (opts.js) {
+        const withInstantiation = opts.instantiation !== undefined;
+        const async_ = instantiation.tag == 'async' ? 'async ' : '';
+        const await_ = instantiation.tag == 'async' ? 'await ' : '';
+
+        // Format the previously generated code.
+        const source = Buffer.from(jsFile[1])
+            .toString('utf8')
+            // update imports manging to match emscripten asm
+            .replace(
+                /exports(\d+)\['([^']+)']/g,
+                (_, i, s) => `exports${i}['${asmMangle(s)}']`
+            )
+            .replace(
+                /export (async )?function instantiate/,
+                '$1function _instantiate'
+            );
+
+        // Collect all Wasm files.
+        const wasmFiles = files.filter(([name]) => name.endsWith('.wasm'));
+        files = files.filter(([name]) => !name.endsWith('.wasm'));
+
+        // Configure the spinner.
+        let completed = 0;
+        const spinnerText = () =>
+            c`{cyan ${completed} / ${wasmFiles.length}} Running Binaryen wasm2js on Wasm core modules (this takes a while)...\n`;
+        if (showSpinner) {
+            spinner = ora({
+                color: 'cyan',
+                spinner: 'bouncingBar',
+            }).start();
+            spinner.text = spinnerText();
         }
-        return output;
-      }));
 
-      const asms = asmFiles.map((asm, nth) => `function asm${nth}(imports) {
+        // Compile all Wasm modules into ASM.js codes.
+        try {
+            const asmFiles = await Promise.all(
+                wasmFiles.map(async ([, source]) => {
+                    const output = (await wasm2Js(source)).toString('utf8');
+                    if (spinner) {
+                        completed++;
+                        spinner.text = spinnerText();
+                    }
+                    return output;
+                })
+            );
+
+            const asms = asmFiles
+                .map(
+                    (asm, nth) => `function asm${nth}(imports) {
   ${
-    // strip and replace the asm instantiation wrapper
-    asm
-      .replace(/import \* as [^ ]+ from '[^']*';/g, '')
-      .replace('function asmFunc(imports) {', '')
-      .replace(/export var ([^ ]+) = ([^. ]+)\.([^ ]+);/g, '')
-      .replace(/var retasmFunc = [\s\S]*$/, '')
-      .replace(/var memasmFunc = new ArrayBuffer\(0\);/g, '')
-      .replace('memory.grow = __wasm_memory_grow;', '')
-      .trim()
-  }`)
-        .join(',\n');
-
-      // The `instantiate` function.
-      const instantiateFunction =
-        `${
-        withInstantiation ? 'export ' : ''
-}${async_}function instantiate(imports) {
+      // strip and replace the asm instantiation wrapper
+      asm
+          .replace(/import \* as [^ ]+ from '[^']*';/g, '')
+          .replace('function asmFunc(imports) {', '')
+          .replace(/export var ([^ ]+) = ([^. ]+)\.([^ ]+);/g, '')
+          .replace(/var retasmFunc = [\s\S]*$/, '')
+          .replace(/var memasmFunc = new ArrayBuffer\(0\);/g, '')
+          .replace('memory.grow = __wasm_memory_grow;', '')
+          .trim()
+  }`
+                )
+                .join(',\n');
+
+            // The `instantiate` function.
+            const instantiateFunction = `${
+                withInstantiation ? 'export ' : ''
+            }${async_}function instantiate(imports) {
   const wasm_file_to_asm_index = {
-    ${wasmFiles.map(([path], nth) => `'${basename(path)}': ${nth}`).join(',\n    ')}
+    ${wasmFiles
+        .map(([path], nth) => `'${basename(path)}': ${nth}`)
+        .join(',\n    ')}
   };
 
   return ${await_}_instantiate(
@@ -374,90 +464,80 @@ export async function transpileComponent (component, opts = {}) {
   );
 }`;
 
-      // If `--js` is used without `--instantiation`.
-      let importDirectives = '';
-      let exportDirectives = '';
-      let exportTrampolines = '';
-      let autoInstantiate = '';
-
-      if (!withInstantiation) {
-        importDirectives = imports
-          .map((import_file, nth) => `import * as import${nth} from '${import_file}';`)
-          .join('\n');
-
-        if (exports.length > 0 || opts.tlaCompat) {
-          exportDirectives =
-            `export {
+            // If `--js` is used without `--instantiation`.
+            let importDirectives = '';
+            let exportDirectives = '';
+            let exportTrampolines = '';
+            let autoInstantiate = '';
+
+            if (!withInstantiation) {
+                importDirectives = imports
+                    .map(
+                        (import_file, nth) =>
+                            `import * as import${nth} from '${import_file}';`
+                    )
+                    .join('\n');
+
+                if (exports.length > 0 || opts.tlaCompat) {
+                    exportDirectives = `export {
 ${
-            // Exporting `$init` must come first to not break the transpiling tests.
-            (opts.tlaCompat) ? '  $init,\n' : ''
-}${
-            exports
-              .map(([name]) => {
-                if (name === asmMangle(name)){
-                  return `  ${name},`;
-                } else {
-                  return `  ${asmMangle(name)} as '${name}',`;
+    // Exporting `$init` must come first to not break the transpiling tests.
+    opts.tlaCompat ? '  $init,\n' : ''
+}${exports
+                        .map(([name]) => {
+                            if (name === asmMangle(name)) {
+                                return `  ${name},`;
+                            } else {
+                                return `  ${asmMangle(name)} as '${name}',`;
+                            }
+                        })
+                        .join('\n')}
+}`;
                 }
-              })
-              .join('\n')
-}
-}`
-        }
 
-        exportTrampolines =
-          `let ${
-          exports
-            .filter(([, ty]) => ty === 'function')
-            .map(([name]) => `_${asmMangle(name)}`)
-            .join(', ')
-          };
-${
-          exports
-            .map(([name, ty]) => {
-              if (ty === 'function') {
-                return `\nfunction ${asmMangle(name)} () {
+                exportTrampolines = `let ${exports
+                    .filter(([, ty]) => ty === 'function')
+                    .map(([name]) => `_${asmMangle(name)}`)
+                    .join(', ')};
+${exports
+    .map(([name, ty]) => {
+        if (ty === 'function') {
+            return `\nfunction ${asmMangle(name)} () {
   return _${asmMangle(name)}.apply(this, arguments);
 }`;
-              } else {
-                return `\nlet ${asmMangle(name)};`;
-              }
-            })
-            .join('\n')
-          }`;
-
-        autoInstantiate =
-          `${async_}function $init() {
+        } else {
+            return `\nlet ${asmMangle(name)};`;
+        }
+    })
+    .join('\n')}`;
+
+                autoInstantiate = `${async_}function $init() {
   ( {
-${
-          exports
-            .map( ([name, ty]) => {
-              if (ty === 'function') {
-                return `    '${ name }': _${ asmMangle(name) },`;
-              } else if (asmMangle(name) === name) {
-                return `    ${ name },`;
-              } else {
-                return `    '${ name }': ${ asmMangle(name) },`;
-              }
-            })
-            .join('\n')
-          }
+${exports
+    .map(([name, ty]) => {
+        if (ty === 'function') {
+            return `    '${name}': _${asmMangle(name)},`;
+        } else if (asmMangle(name) === name) {
+            return `    ${name},`;
+        } else {
+            return `    '${name}': ${asmMangle(name)},`;
+        }
+    })
+    .join('\n')}
   } = ${await_}instantiate(
     {
-${
-          imports
-            .map((import_file, nth) => `      '${import_file}': import${ nth },`)
-            .join('\n')
-          }
+${imports
+    .map((import_file, nth) => `      '${import_file}': import${nth},`)
+    .join('\n')}
     }
   ) )
 }
 
-${ opts.tlaCompat ? '' : `${await_}$init();`}`;
-      }
+${opts.tlaCompat ? '' : `${await_}$init();`}`;
+            }
 
-      // Prepare the final generated code.
-      const outSource = `${importDirectives}
+            // Prepare the final generated code.
+            const outSource = `${importDirectives}
 
 ${source}
 
@@ -471,192 +551,225 @@ ${exportDirectives}
 
 ${autoInstantiate}`;
 
-      // Save the final generated code.
-      jsFile[1] = Buffer.from(outSource);
+            // Save the final generated code.
+            jsFile[1] = Buffer.from(outSource);
+        } finally {
+            if (spinner) {
+                spinner.stop();
+            }
+        }
     }
-    finally {
-      if (spinner) {
-        spinner.stop();
-      }
+
+    if (opts.minify) {
+        ({ code: jsFile[1] } = await minify(
+            Buffer.from(jsFile[1]).toString('utf8'),
+            {
+                module: true,
+                compress: {
+                    ecma: 9,
+                    unsafe: true,
+                },
+                mangle: {
+                    keep_classnames: true,
+                },
+            }
+        ));
     }
-  }
-
-  if (opts.minify) {
-    ({ code: jsFile[1] } = await minify(Buffer.from(jsFile[1]).toString('utf8'), {
-      module: true,
-      compress: {
-        ecma: 9,
-        unsafe: true
-      },
-      mangle: {
-        keep_classnames: true
-      }
-    }));
-  }
-
-  return { files: Object.fromEntries(files), imports, exports };
+
+    return { files: Object.fromEntries(files), imports, exports };
 }
 
 // emscripten asm mangles specifiers to be valid identifiers
 // for imports to match up we must do the same
 // See https://github.com/WebAssembly/binaryen/blob/main/src/asmjs/asmangle.cpp
-function asmMangle (name) {
-  if (name === '')
-    return '$';
-
-  let mightBeKeyword = true;
-  let i = 1;
-
-  // Names must start with a character, $ or _
-  switch (name[0]) {
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      name = '$' + name;
-      i = 2;
-      // fallthrough
-    }
-    case '$':
-    case '_': {
-      mightBeKeyword = false;
-      break;
-    }
-    default: {
-      let chNum = name.charCodeAt(0);
-      if (!(chNum >= 97 && chNum <= 122) && !(chNum >= 65 && chNum <= 90)) {
-        name = '$' + name.substr(1);
-        mightBeKeyword = false;
-      }
+function asmMangle(name) {
+    if (name === '') return '$';
+
+    let mightBeKeyword = true;
+    let i = 1;
+
+    // Names must start with a character, $ or _
+    switch (name[0]) {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9': {
+            name = '$' + name;
+            i = 2;
+            // fallthrough
+        }
+        case '$':
+        case '_': {
+            mightBeKeyword = false;
+            break;
+        }
+        default: {
+            let chNum = name.charCodeAt(0);
+            if (
+                !(chNum >= 97 && chNum <= 122) &&
+                !(chNum >= 65 && chNum <= 90)
+            ) {
+                name = '$' + name.substr(1);
+                mightBeKeyword = false;
+            }
+        }
     }
-  }
-
-  // Names must contain only characters, digits, $ or _
-  let len = name.length;
-  for (; i < len; ++i) {
-    switch (name[i]) {
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9':
-      case '$':
-      case '_': {
-        mightBeKeyword = false;
-        break;
-      }
-      default: {
-        let chNum = name.charCodeAt(i);
-        if (!(chNum >= 97 && chNum <= 122) && !(chNum >= 65 && chNum <= 90)) {
-          name = name.substr(0, i) + '_' + name.substr(i + 1);
-          mightBeKeyword = false;
+
+    // Names must contain only characters, digits, $ or _
+    let len = name.length;
+    for (; i < len; ++i) {
+        switch (name[i]) {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            case '$':
+            case '_': {
+                mightBeKeyword = false;
+                break;
+            }
+            default: {
+                let chNum = name.charCodeAt(i);
+                if (
+                    !(chNum >= 97 && chNum <= 122) &&
+                    !(chNum >= 65 && chNum <= 90)
+                ) {
+                    name = name.substr(0, i) + '_' + name.substr(i + 1);
+                    mightBeKeyword = false;
+                }
+            }
         }
-      }
     }
-  }
 
-  // Names must not collide with keywords
-  if (mightBeKeyword && len >= 2 && len <= 10) {
-    switch (name[0]) {
-      case 'a': {
-        if (name == "arguments")
-          return name + '_';
-        break;
-      }
-      case 'b': {
-        if (name == "break")
-          return name + '_';
-        break;
-      }
-      case 'c': {
-        if (name == "case" || name == "continue" || name == "catch" ||
-            name == "const" || name == "class")
-          return name + '_';
-        break;
-      }
-      case 'd': {
-        if (name == "do" || name == "default" || name == "debugger")
-          return name + '_';
-        break;
-      }
-      case 'e': {
-        if (name == "else" || name == "enum" || name == "eval" || // to be sure
-            name == "export" || name == "extends")
-          return name + '_';
-        break;
-      }
-      case 'f': {
-        if (name == "for" || name == "false" || name == "finally" ||
-            name == "function")
-          return name + '_';
-        break;
-      }
-      case 'i': {
-        if (name == "if" || name == "in" || name == "import" ||
-            name == "interface" || name == "implements" ||
-            name == "instanceof")
-          return name + '_';
-        break;
-      }
-      case 'l': {
-        if (name == "let")
-          return name + '_';
-        break;
-      }
-      case 'n': {
-        if (name == "new" || name == "null")
-          return name + '_';
-        break;
-      }
-      case 'p': {
-        if (name == "public" || name == "package" || name == "private" ||
-            name == "protected")
-          return name + '_';
-        break;
-      }
-      case 'r': {
-        if (name == "return")
-          return name + '_';
-        break;
-      }
-      case 's': {
-        if (name == "super" || name == "static" || name == "switch")
-          return name + '_';
-        break;
-      }
-      case 't': {
-        if (name == "try" || name == "this" || name == "true" ||
-            name == "throw" || name == "typeof")
-          return name + '_';
-        break;
-      }
-      case 'v': {
-        if (name == "var" || name == "void")
-          return name + '_';
-        break;
-      }
-      case 'w': {
-        if (name == "with" || name == "while")
-          return name + '_';
-        break;
-      }
-      case 'y': {
-        if (name == "yield")
-          return name + '_';
-        break;
-      }
+    // Names must not collide with keywords
+    if (mightBeKeyword && len >= 2 && len <= 10) {
+        switch (name[0]) {
+            case 'a': {
+                if (name == 'arguments') return name + '_';
+                break;
+            }
+            case 'b': {
+                if (name == 'break') return name + '_';
+                break;
+            }
+            case 'c': {
+                if (
+                    name == 'case' ||
+                    name == 'continue' ||
+                    name == 'catch' ||
+                    name == 'const' ||
+                    name == 'class'
+                )
+                    return name + '_';
+                break;
+            }
+            case 'd': {
+                if (name == 'do' || name == 'default' || name == 'debugger')
+                    return name + '_';
+                break;
+            }
+            case 'e': {
+                if (
+                    name == 'else' ||
+                    name == 'enum' ||
+                    name == 'eval' || // to be sure
+                    name == 'export' ||
+                    name == 'extends'
+                )
+                    return name + '_';
+                break;
+            }
+            case 'f': {
+                if (
+                    name == 'for' ||
+                    name == 'false' ||
+                    name == 'finally' ||
+                    name == 'function'
+                )
+                    return name + '_';
+                break;
+            }
+            case 'i': {
+                if (
+                    name == 'if' ||
+                    name == 'in' ||
+                    name == 'import' ||
+                    name == 'interface' ||
+                    name == 'implements' ||
+                    name == 'instanceof'
+                )
+                    return name + '_';
+                break;
+            }
+            case 'l': {
+                if (name == 'let') return name + '_';
+                break;
+            }
+            case 'n': {
+                if (name == 'new' || name == 'null') return name + '_';
+                break;
+            }
+            case 'p': {
+                if (
+                    name == 'public' ||
+                    name == 'package' ||
+                    name == 'private' ||
+                    name == 'protected'
+                )
+                    return name + '_';
+                break;
+            }
+            case 'r': {
+                if (name == 'return') return name + '_';
+                break;
+            }
+            case 's': {
+                if (name == 'super' || name == 'static' || name == 'switch')
+                    return name + '_';
+                break;
+            }
+            case 't': {
+                if (
+                    name == 'try' ||
+                    name == 'this' ||
+                    name == 'true' ||
+                    name == 'throw' ||
+                    name == 'typeof'
+                )
+                    return name + '_';
+                break;
+            }
+            case 'v': {
+                if (name == 'var' || name == 'void') return name + '_';
+                break;
+            }
+            case 'w': {
+                if (name == 'with' || name == 'while') return name + '_';
+                break;
+            }
+            case 'y': {
+                if (name == 'yield') return name + '_';
+                break;
+            }
+        }
     }
-  }
-  return name;
+    return name;
+}
+
+// see: https://github.com/vitest-dev/vitest/issues/6953#issuecomment-2505310022
+if (typeof __vite_ssr_import_meta__ !== 'undefined') {
+    __vite_ssr_import_meta__.resolve = (path) =>
+        'file://' + globalCreateRequire(import.meta.url).resolve(path);
 }