@bytecodealliance/jco 0.13.2 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/jco",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "JavaScript tooling for working with WebAssembly Components",
   "author": "Guy Bedford",
   "bin": {
@@ -18,7 +18,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@bytecodealliance/preview2-shim": "0.0.20",
+    "@bytecodealliance/preview2-shim": "0.14.0",
     "binaryen": "^111.0.0",
     "chalk-template": "^0.4.0",
     "commander": "^9.4.1",
@@ -27,7 +27,7 @@
     "terser": "^5.16.1"
   },
   "devDependencies": {
-    "@bytecodealliance/componentize-js": "^0.4.0",
+    "@bytecodealliance/componentize-js": "^0.4.1",
     "@types/node": "^18.11.17",
     "@typescript-eslint/eslint-plugin": "^5.41.0",
     "@typescript-eslint/parser": "^5.41.0",

package/src/api.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @param {Parameters<import('../obj/wasm-tools.js').print>[0]} binary
+ * @return {Promise<ReturnType<import('../obj/wasm-tools.js').print>>}
+ */
+export function print(binary: Parameters<import('../obj/wasm-tools.js').print>[0]): Promise<ReturnType<import('../obj/wasm-tools.js').print>>;
+/**
+ * @param {Parameters<import('../obj/wasm-tools.js').parse>[0]} wat
+ * @return {Promise<ReturnType<import('../obj/wasm-tools.js').parse>>}
+ */
+export function parse(wat: Parameters<import('../obj/wasm-tools.js').parse>[0]): Promise<ReturnType<import('../obj/wasm-tools.js').parse>>;
+/**
+ * @param {Parameters<import('../obj/wasm-tools.js').componentWit>[0]} binary
+ * @return {Promise<ReturnType<import('../obj/wasm-tools.js').componentWit>>}
+ */
+export function componentWit(binary: Parameters<import('../obj/wasm-tools.js').componentWit>[0]): Promise<ReturnType<import('../obj/wasm-tools.js').componentWit>>;
+/**
+ * @param {Parameters<import('../obj/wasm-tools.js').componentNew>[0]} binary
+ * @param {Parameters<import('../obj/wasm-tools.js').componentNew>[1]} adapters
+ * @return {Promise<ReturnType<import('../obj/wasm-tools.js').componentNew>>}
+ */
+export function componentNew(binary: Parameters<import('../obj/wasm-tools.js').componentNew>[0], adapters: Parameters<import('../obj/wasm-tools.js').componentNew>[1]): Promise<ReturnType<import('../obj/wasm-tools.js').componentNew>>;
+/**
+ * @param {Parameters<import('../obj/wasm-tools.js').componentEmbed>[0]} embedOpts
+ * @return {Promise<ReturnType<import('../obj/wasm-tools.js').componentEmbed>>}
+ */
+export function componentEmbed(embedOpts: Parameters<import('../obj/wasm-tools.js').componentEmbed>[0]): Promise<ReturnType<import('../obj/wasm-tools.js').componentEmbed>>;
+/**
+ * @param {Parameters<import('../obj/wasm-tools.js').metadataAdd>[0]} binary
+ * @param {Parameters<import('../obj/wasm-tools.js').metadataAdd>[1]} metadata
+ * @return {Promise<ReturnType<import('../obj/wasm-tools.js').metadataAdd>>}
+ */
+export function metadataAdd(binary: Parameters<import('../obj/wasm-tools.js').metadataAdd>[0], metadata: Parameters<import('../obj/wasm-tools.js').metadataAdd>[1]): Promise<ReturnType<import('../obj/wasm-tools.js').metadataAdd>>;
+/**
+ * @param {Parameters<import('../obj/wasm-tools.js').metadataShow>[0]} binary
+ * @return {Promise<ReturnType<import('../obj/wasm-tools.js').metadataShow>>}
+ */
+export function metadataShow(binary: Parameters<import('../obj/wasm-tools.js').metadataShow>[0]): Promise<ReturnType<import('../obj/wasm-tools.js').metadataShow>>;
+export function preview1AdapterCommandPath(): URL;
+export function preview1AdapterReactorPath(): URL;
+export { optimizeComponent as opt } from "./cmd/opt.js";
+export { transpileComponent as transpile } from "./cmd/transpile.js";
+//# sourceMappingURL=api.d.ts.map

package/src/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["api.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,8BAHW,WAAW,OAAO,sBAAsB,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAClD,QAAQ,WAAW,OAAO,sBAAsB,EAAE,KAAK,CAAC,CAAC,CAKpE;AACD;;;GAGG;AACH,2BAHW,WAAW,OAAO,sBAAsB,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAClD,QAAQ,WAAW,OAAO,sBAAsB,EAAE,KAAK,CAAC,CAAC,CAKpE;AACD;;;GAGG;AACH,qCAHW,WAAW,OAAO,sBAAsB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,GACzD,QAAQ,WAAW,OAAO,sBAAsB,EAAE,YAAY,CAAC,CAAC,CAK3E;AACD;;;;GAIG;AACH,qCAJW,WAAW,OAAO,sBAAsB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,YAC1D,WAAW,OAAO,sBAAsB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,GACzD,QAAQ,WAAW,OAAO,sBAAsB,EAAE,YAAY,CAAC,CAAC,CAK3E;AACD;;;GAGG;AACH,0CAHW,WAAW,OAAO,sBAAsB,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,GAC3D,QAAQ,WAAW,OAAO,sBAAsB,EAAE,cAAc,CAAC,CAAC,CAK7E;AACD;;;;GAIG;AACH,oCAJW,WAAW,OAAO,sBAAsB,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,YACzD,WAAW,OAAO,sBAAsB,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GACxD,QAAQ,WAAW,OAAO,sBAAsB,EAAE,WAAW,CAAC,CAAC,CAK1E;AACD;;;GAGG;AACH,qCAHW,WAAW,OAAO,sBAAsB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,GACzD,QAAQ,WAAW,OAAO,sBAAsB,EAAE,YAAY,CAAC,CAAC,CAK3E;AACD,kDAEC;AACD,kDAEC"}

package/src/browser.d.ts

@@ -0,0 +1,4 @@
+import { generate } from "../obj/js-component-bindgen-component.js";
+import { generateTypes } from "../obj/js-component-bindgen-component.js";
+export { generate as transpile, generateTypes };
+//# sourceMappingURL=browser.d.ts.map

package/src/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["browser.js"],"names":[],"mappings":""}

package/src/cmd/componentize.d.ts

@@ -0,0 +1,2 @@
+export function componentize(jsSource: any, opts: any): Promise<void>;
+//# sourceMappingURL=componentize.d.ts.map

package/src/cmd/componentize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentize.d.ts","sourceRoot":"","sources":["componentize.js"],"names":[],"mappings":"AAIA,sEAkBC"}

package/src/cmd/componentize.js

@@ -1,6 +1,7 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import c from 'chalk-template';
+import { isWindows } from '../common.js';
 
 export async function componentize (jsSource, opts) {
   let componentizeFn;

package/src/cmd/opt.d.ts

@@ -0,0 +1,15 @@
+export function opt(componentPath: any, opts: any, program: any): Promise<void>;
+/**
+ *
+ * @param {Uint8Array} componentBytes
+ * @param {{ quiet: boolean, optArgs?: string[] }} options?
+ * @returns {Promise<{ component: Uint8Array, compressionInfo: { beforeBytes: number, afterBytes: number }[] >}
+ */
+export function optimizeComponent(componentBytes: Uint8Array, opts: any): Promise<{
+    component: Uint8Array;
+    compressionInfo: {
+        beforeBytes: number;
+        afterBytes: number;
+    }[];
+}>;
+//# sourceMappingURL=opt.d.ts.map

package/src/cmd/opt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opt.d.ts","sourceRoot":"","sources":["opt.js"],"names":[],"mappings":"AAeA,gFAoCC;AAED;;;;;GAKG;AACH,kDAJW,UAAU,cAER,QAAQ;IAAE,SAAS,EAAE,UAAU,CAAC;IAAC,eAAe,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAA,CAAE,CA8E7G"}

package/src/cmd/run.d.ts

@@ -0,0 +1,2 @@
+export function run(componentPath: any, args: any, opts: any): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

package/src/cmd/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["run.js"],"names":[],"mappings":"AASA,6EA+FC"}

package/src/cmd/run.js

@@ -4,15 +4,20 @@ import { rm, stat, mkdir, writeFile, symlink } from 'node:fs/promises';
 import { basename, resolve, extname } from 'node:path';
 import { fork } from 'node:child_process';
 import process from 'node:process';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import c from 'chalk-template';
 
-export async function run (componentPath, args) {
+export async function run (componentPath, args, opts) {
   // Ensure that `args` is an array
   args = [...args];
 
+  const jcoImport = opts.jcoImport ? resolve(opts.jcoImport) : null;
+
   const name = basename(componentPath.slice(0, -extname(componentPath).length || Infinity));
-  const outDir = await getTmpDir();
+  const outDir = opts.jcoDir || await getTmpDir();
+  if (opts.jcoDir) {
+    await mkdir(outDir, { recursive: true });
+  }
   try {
     try {
       await transpile(componentPath, {
@@ -20,7 +25,8 @@ export async function run (componentPath, args) {
         quiet: true,
         noTypescript: true,
         wasiShim: true,
-        outDir
+        outDir,
+        tracing: opts.jcoTrace
       });
     }
     catch (e) {
@@ -46,14 +52,22 @@ export async function run (componentPath, args) {
 
     const modulesDir = resolve(outDir, 'node_modules', '@bytecodealliance');
     await mkdir(modulesDir, { recursive: true });
-    await symlink(preview2ShimPath, resolve(modulesDir, 'preview2-shim'), 'dir');
+
+    try {
+      await symlink(preview2ShimPath, resolve(modulesDir, 'preview2-shim'), 'dir');
+    } catch (e) {
+      if (e.code !== 'EEXIST')
+        throw e;
+    }
 
     const runPath = resolve(outDir, '_run.js');
     await writeFile(runPath, `
+      ${jcoImport ? `import ${JSON.stringify(pathToFileURL(jcoImport))}` : ''}
       function logInvalidCommand () {
         console.error('Not a valid command component to execute, make sure it was built to a command adapter and with the same version.');
       }
       try {
+        process.argv[1] = "${name}";
         const mod = await import('./${name}.js');
         if (!mod.run || !mod.run.run) {
           logInvalidCommand();
@@ -61,6 +75,8 @@ export async function run (componentPath, args) {
         }
         try {
           mod.run.run();
+          // TODO: figure out stdout flush!
+          setTimeout(() => {});
         }
         catch (e) {
           console.error(e);
@@ -82,7 +98,8 @@ export async function run (componentPath, args) {
   }
   finally {
     try {
-      await rm(outDir, { recursive: true });
+      if (!opts.jcoDir)
+        await rm(outDir, { recursive: true });
     } catch {}
   }
 }

package/src/cmd/transpile.d.ts

@@ -0,0 +1,44 @@
+export function transpile(componentPath: any, opts: any, program: any): Promise<void>;
+/**
+ *
+ * @param {Uint8Array} component
+ * @param {{
+ *   name: string,
+ *   instantiation?: 'async' | 'sync',
+ *   map?: Record<string, string>,
+ *   validLiftingOptimization?: bool,
+ *   tracing?: bool,
+ *   noNodejsCompat?: bool,
+ *   tlaCompat?: bool,
+ *   base64Cutoff?: bool,
+ *   js?: bool,
+ *   minify?: bool,
+ *   optimize?: bool,
+ *   noNamespacedExports?: bool,
+ *   optArgs?: string[],
+ * }} opts
+ * @returns {Promise<{ files: { [filename: string]: Uint8Array }, imports: string[], exports: [string, 'function' | 'instance'][] }>}
+ */
+export function transpileComponent(component: Uint8Array, opts?: {
+    name: string;
+    instantiation?: 'async' | 'sync';
+    map?: Record<string, string>;
+    validLiftingOptimization?: bool;
+    tracing?: bool;
+    noNodejsCompat?: bool;
+    tlaCompat?: bool;
+    base64Cutoff?: bool;
+    js?: bool;
+    minify?: bool;
+    optimize?: bool;
+    noNamespacedExports?: bool;
+    optArgs?: string[];
+}): Promise<{
+    files: {
+        [filename: string]: Uint8Array;
+    };
+    imports: string[];
+    exports: [string, 'function' | 'instance'][];
+}>;
+import { minify } from "terser";
+//# sourceMappingURL=transpile.d.ts.map

package/src/cmd/transpile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpile.d.ts","sourceRoot":"","sources":["transpile.js"],"names":[],"mappings":"AAWA,sFA2BC;AAuBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8CAlBW,UAAU;UAEV,MAAM;oBACI,OAAO,GAAG,MAAM;UAC1B,OAAO,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;cAUlB,MAAM,EAAE;;;;;aAEoD,MAAM,EAAE;aAAW,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC,EAAE;GA4IhI"}

package/src/cmd/transpile.js

@@ -46,7 +46,7 @@ try {
 }
 
 /**
- * @param {Uint8Array} source 
+ * @param {Uint8Array} source
  * @returns {Promise<Uint8Array>}
  */
 async function wasm2Js (source) {
@@ -60,22 +60,23 @@ async function wasm2Js (source) {
 }
 
 /**
- * 
- * @param {Uint8Array} component 
+ *
+ * @param {Uint8Array} component
  * @param {{
  *   name: string,
- *   instantiation?: bool,
+ *   instantiation?: 'async' | 'sync',
  *   map?: Record<string, string>,
  *   validLiftingOptimization?: bool,
  *   tracing?: bool,
- *   noNodejsCompat?: bool,
+ *   nodejsCompat?: bool,
  *   tlaCompat?: bool,
  *   base64Cutoff?: bool,
  *   js?: bool,
  *   minify?: bool,
  *   optimize?: bool,
+ *   namespacedExports?: bool,
  *   optArgs?: string[],
- * }} opts 
+ * }} opts
  * @returns {Promise<{ files: { [filename: string]: Uint8Array }, imports: string[], exports: [string, 'function' | 'instance'][] }>}
  */
 export async function transpileComponent (component, opts = {}) {
@@ -103,16 +104,28 @@ export async function transpileComponent (component, opts = {}) {
     }, 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' };
+  }
+
   let { files, imports, exports } = generate(component, {
     name: opts.name ?? 'component',
     map: Object.entries(opts.map ?? {}),
-    instantiation: opts.instantiation || opts.js,
+    instantiation,
     validLiftingOptimization: opts.validLiftingOptimization ?? false,
     tracing: opts.tracing ?? false,
     noNodejsCompat: !(opts.nodejsCompat ?? true),
     noTypescript: opts.noTypescript || false,
     tlaCompat: opts.tlaCompat ?? false,
-    base64Cutoff: opts.js ? 0 : opts.base64Cutoff ?? 5000
+    base64Cutoff: opts.js ? 0 : opts.base64Cutoff ?? 5000,
+    noNamespacedExports: opts.namespacedExports === false,
   });
 
   let outDir = (opts.outDir ?? '').replace(/\\/g, '/');
@@ -122,16 +135,67 @@ export async function transpileComponent (component, opts = {}) {
 
   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(/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'));
 
-    // TODO: imports as specifier list
-
+    // 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) {
@@ -142,6 +206,7 @@ export async function transpileComponent (component, opts = {}) {
       spinner.text = spinnerText();
     }
 
+    // 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');
@@ -152,44 +217,140 @@ export async function transpileComponent (component, opts = {}) {
         return output;
       }));
 
-      const asms = asmFiles.map((asm, i) =>`function asm${i}(imports) {
+      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');
-
-      const outSource = `${
-        imports.map((impt, i) => `import * as import${i} from '${impt}';`).join('\n')}
-${source.replace('export async function instantiate', 'async function instantiate')}
-
-let ${exports.filter(([, ty]) => ty === 'function').map(([name]) => '_' + name).join(', ')};
-
-${exports.map(([name, ty]) => ty === 'function' ? `\nfunction ${asmMangle(name)} () {
-  return _${name}.apply(this, arguments);
-}` : `\nlet ${asmMangle(name)};`).join('\n')}
+    // 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    ')}
+  };
+
+  return ${await_}_instantiate(
+      module_name => wasm_file_to_asm_index[module_name],
+      imports,
+      (module_index, imports) => ({ exports: asmInit[module_index](imports) })
+  );
+}`;
+
+      // 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}',`;
+                }
+              })
+              .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)} () {
+  return _${asmMangle(name)}.apply(this, arguments);
+}`;
+              } 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')
+          }
+  } = ${await_}instantiate(
+    {
+${
+          imports
+            .map((import_file, nth) => `      '${import_file}': import${ nth },`)
+            .join('\n')
+          }
+    }
+  ) )
+}
+
+${ opts.tlaCompat ? '' : `${await_}$init();`}`;
+      }
+
+      // Prepare the final generated code.
+      const outSource = `${importDirectives}
+
+${source}
 
 const asmInit = [${asms}];
 
-${opts.tlaCompat ? 'export ' : ''}const $init = (async () => {
-  let idx = 0;
-  ({ ${exports.map(([name, ty]) => asmMangle(name) === name ? name : `'${name}': ${asmMangle(name)}`).join(',\n')} } = await instantiate(n => idx++, {
-${imports.map((impt, i) => `    '${impt}': import${i},`).join('\n')}
-  }, (i, imports) => ({ exports: asmInit[i](imports) })));
-})();${exports.length > 0 ? `\nexport { ${exports.map(([name]) => name === asmMangle(name) ? `${name}` : `${asmMangle(name)} as "${name}"`).join(', ')} }` : ''}
-${opts.tlaCompat ? '' : '\nawait $init;\n'}`;
+${exportTrampolines}
+
+${instantiateFunction}
 
+${exportDirectives}
+
+${autoInstantiate}`;
+
+      // Save the final generated code.
       jsFile[1] = Buffer.from(outSource);
     }
     finally {
-      if (spinner)
+      if (spinner) {
         spinner.stop();
+      }
     }
   }
 
@@ -215,10 +376,10 @@ ${opts.tlaCompat ? '' : '\nawait $init;\n'}`;
 function asmMangle (name) {
   if (name === '')
     return '$';
-  
+
   let mightBeKeyword = true;
   let i = 1;
-  
+
   // Names must start with a character, $ or _
   switch (name[0]) {
     case '0':
@@ -248,7 +409,7 @@ function asmMangle (name) {
       }
     }
   }
-  
+
   // Names must contain only characters, digits, $ or _
   let len = name.length;
   for (; i < len; ++i) {
@@ -277,7 +438,7 @@ function asmMangle (name) {
       }
     }
   }
-  
+
   // Names must not collide with keywords
   if (mightBeKeyword && len >= 2 && len <= 10) {
     switch (name[0]) {

package/src/cmd/wasm-tools.d.ts

@@ -0,0 +1,8 @@
+export function parse(file: any, opts: any): Promise<void>;
+export function print(file: any, opts: any): Promise<void>;
+export function componentWit(file: any, opts: any): Promise<void>;
+export function componentNew(file: any, opts: any): Promise<void>;
+export function componentEmbed(file: any, opts: any): Promise<void>;
+export function metadataAdd(file: any, opts: any): Promise<void>;
+export function metadataShow(file: any, opts: any): Promise<void>;
+//# sourceMappingURL=wasm-tools.d.ts.map

package/src/cmd/wasm-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-tools.d.ts","sourceRoot":"","sources":["wasm-tools.js"],"names":[],"mappings":"AAOA,2DAKC;AAED,2DASC;AAED,kEASC;AAED,kEAsBC;AAED,oEAaC;AAED,iEAUC;AAED,kEAiCC"}

package/src/cmd/wasm-tools.js

@@ -1,9 +1,10 @@
 import { writeFile } from "node:fs/promises";
-import { readFile } from '../common.js';
+import { readFile, isWindows } from '../common.js';
 import { $init, tools } from "../../obj/wasm-tools.js";
 const { print: printFn, parse: parseFn, componentWit: componentWitFn, componentNew: componentNewFn, componentEmbed: componentEmbedFn, metadataAdd: metadataAddFn, metadataShow: metadataShowFn } = tools;
 import { resolve, basename, extname } from 'node:path';
 import c from 'chalk-template';
+import { platform } from 'node:process';
 
 export async function parse(file, opts) {
   await $init;
@@ -68,7 +69,7 @@ export async function componentEmbed(file, opts) {
     });
   const source = file ? await readFile(file) : null;
   opts.binary = source;
-  opts.witPath = resolve(opts.wit);
+  opts.witPath = (isWindows ? '//?/' : '') + resolve(opts.wit);
   const output = componentEmbedFn(opts);
   await writeFile(opts.output, output);
 }

package/src/common.d.ts

@@ -0,0 +1,16 @@
+export function setShowSpinner(val: any): void;
+export function getShowSpinner(): boolean;
+export function sizeStr(num: any): string;
+export function fixedDigitDisplay(num: any, maxChars: any): string;
+export function table(data: any, align?: any[]): string;
+/**
+ * Securely creates a temporary directory and returns its path.
+ *
+ * The new directory is created using `fsPromises.mkdtemp()`.
+ */
+export function getTmpDir(): Promise<string>;
+export function spawnIOTmp(cmd: any, input: any, args: any): Promise<Buffer>;
+export const isWindows: boolean;
+export { readFileCli as readFile };
+declare function readFileCli(file: any, encoding: any): Promise<Buffer>;
+//# sourceMappingURL=common.d.ts.map

package/src/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["common.js"],"names":[],"mappings":"AAWA,+CAEC;AACD,0CAIC;AAED,0CAOC;AAED,mEAaC;AAED,wDAcC;AAED;;;;GAIG;AACH,6CAEC;AAYD,6EA8BC;AArGD,gCAA8C;;AA6D9C,wEAOC"}