@bytecodealliance/jco 1.9.1 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/jco",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "JavaScript tooling for working with WebAssembly Components",
   "author": "Guy Bedford",
   "bin": {
@@ -24,9 +24,9 @@
   },
   "type": "module",
   "dependencies": {
-    "@bytecodealliance/componentize-js": "^0.15.0",
+    "@bytecodealliance/componentize-js": "^0.17.0",
     "@bytecodealliance/preview2-shim": "^0.17.1",
-    "binaryen": "^120.0.0",
+    "binaryen": "^122.0.0",
     "chalk-template": "^1",
     "commander": "^12",
     "mkdirp": "^3",
@@ -62,8 +62,8 @@
     "build:release": "cargo xtask build release",
     "build:types:preview2-shim": "cargo xtask generate wasi-types",
     "lint": "eslint -c eslintrc.cjs src/**/*.js packages/*/lib/**/*.js",
-    "test:lts": "mocha -u tdd test/test.js --timeout 120000",
-    "test": "node --stack-trace-limit=100 node_modules/mocha/bin/mocha.js -u tdd test/test.js --timeout 120000",
+    "test:lts": "mocha -u tdd test/test.js --timeout 240000",
+    "test": "node --experimental-wasm-jspi --stack-trace-limit=100 node_modules/mocha/bin/mocha.js -u tdd test/test.js --timeout 240000",
     "prepublishOnly": "cargo xtask build release && npm run test"
   },
   "files": [

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

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

package/src/cmd/opt.d.ts

@@ -2,10 +2,15 @@ export function opt(componentPath: any, opts: any, program: any): Promise<void>;
 /**
  *
  * @param {Uint8Array} componentBytes
- * @param {{ quiet: boolean, optArgs?: string[] }} options?
+ * @param {{ quiet: boolean, asyncify?: boolean, optArgs?: string[], noVerify?: boolean }} opts?
  * @returns {Promise<{ component: Uint8Array, compressionInfo: { beforeBytes: number, afterBytes: number }[] >}
  */
-export function optimizeComponent(componentBytes: Uint8Array, opts: any): Promise<{
+export function optimizeComponent(componentBytes: Uint8Array, opts: {
+    quiet: boolean;
+    asyncify?: boolean;
+    optArgs?: string[];
+    noVerify?: boolean;
+}): Promise<{
     component: Uint8Array;
     compressionInfo: {
         beforeBytes: number;

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

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

package/src/cmd/opt.js

@@ -1,16 +1,23 @@
-import { $init, tools } from '../../obj/wasm-tools.js';
+import { $init, tools } from "../../obj/wasm-tools.js";
 const { metadataShow, print } = tools;
-import { writeFile } from 'fs/promises';
-import { fileURLToPath } from 'url';
-import c from 'chalk-template';
-import { readFile, sizeStr, fixedDigitDisplay, table, spawnIOTmp, setShowSpinner, getShowSpinner } from '../common.js';
-import ora from '#ora';
+import { writeFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import c from "chalk-template";
+import {
+  readFile,
+  sizeStr,
+  fixedDigitDisplay,
+  table,
+  spawnIOTmp,
+  setShowSpinner,
+  getShowSpinner,
+} from "../common.js";
+import ora from "#ora";
 
-export async function opt (componentPath, opts, program) {
+export async function opt(componentPath, opts, program) {
   await $init;
-  const varIdx = program.parent.rawArgs.indexOf('--');
-  if (varIdx !== -1)
-    opts.optArgs = program.parent.rawArgs.slice(varIdx + 1);
+  const varIdx = program.parent.rawArgs.indexOf("--");
+  if (varIdx !== -1) opts.optArgs = program.parent.rawArgs.slice(varIdx + 1);
   const componentBytes = await readFile(componentPath);
 
   if (!opts.quiet) setShowSpinner(true);
@@ -19,128 +26,235 @@ export async function opt (componentPath, opts, program) {
 
   await writeFile(opts.output, component);
 
-  let totalBeforeBytes = 0, totalAfterBytes = 0;
+  let totalBeforeBytes = 0,
+    totalAfterBytes = 0;
 
   if (!opts.quiet)
     console.log(c`
 {bold Optimized WebAssembly Component Internal Core Modules:}
 
-${table([...compressionInfo.map(({ beforeBytes, afterBytes }, i) => {
-  totalBeforeBytes += beforeBytes;
-  totalAfterBytes += afterBytes;
-  return [
-    ` - Core Module ${i + 1}:  `,
-    sizeStr(beforeBytes),
-    ' -> ',
-    c`{cyan ${sizeStr(afterBytes)}} `,
-    `(${fixedDigitDisplay(afterBytes / beforeBytes * 100, 2)}%)`
-  ];
-}), ['', '', '', '', ''], [
-  ` = Total:  `,
-  `${sizeStr(totalBeforeBytes)}`,
-  ` => `,
-  c`{cyan ${sizeStr(totalAfterBytes)}} `,
-  `(${fixedDigitDisplay(totalAfterBytes / totalBeforeBytes * 100, 2)}%)`
-]], [,,,,'right'])}`);
+${table(
+  [
+    ...compressionInfo.map(({ beforeBytes, afterBytes }, i) => {
+      totalBeforeBytes += beforeBytes;
+      totalAfterBytes += afterBytes;
+      return [
+        ` - Core Module ${i + 1}:  `,
+        sizeStr(beforeBytes),
+        " -> ",
+        c`{cyan ${sizeStr(afterBytes)}} `,
+        `(${fixedDigitDisplay((afterBytes / beforeBytes) * 100, 2)}%)`,
+      ];
+    }),
+    ["", "", "", "", ""],
+    [
+      ` = Total:  `,
+      `${sizeStr(totalBeforeBytes)}`,
+      ` => `,
+      c`{cyan ${sizeStr(totalAfterBytes)}} `,
+      `(${fixedDigitDisplay((totalAfterBytes / totalBeforeBytes) * 100, 2)}%)`,
+    ],
+  ],
+  [, , , , "right"]
+)}`);
 }
 
 /**
- * 
- * @param {Uint8Array} componentBytes 
- * @param {{ quiet: boolean, optArgs?: string[] }} options?
+ * Counts the byte length for the LEB128 encoding of a number.
+ * @param {number} val
+ * @returns {number}
+ */
+function byteLengthLEB128(val) {
+  let len = 0;
+  do {
+    val >>>= 7;
+    len++;
+  } while (val !== 0);
+  return len;
+}
+
+/**
+ *
+ * @param {Uint8Array} componentBytes
+ * @param {{ quiet: boolean, asyncify?: boolean, optArgs?: string[], noVerify?: boolean }} opts?
  * @returns {Promise<{ component: Uint8Array, compressionInfo: { beforeBytes: number, afterBytes: number }[] >}
  */
-export async function optimizeComponent (componentBytes, opts) {
+export async function optimizeComponent(componentBytes, opts) {
   await $init;
   const showSpinner = getShowSpinner();
   let spinner;
   try {
-    const coreModules = metadataShow(componentBytes).slice(1, -1).map(({ range }) => range);
+    let componentMetadata = metadataShow(componentBytes);
+    componentMetadata.forEach((metadata, index) => {
+        // add index to the metadata object
+        metadata.index = index;
+        const size = metadata.range[1] - metadata.range[0];
+        // compute previous LEB128 encoding length
+        metadata.prevLEBLen = byteLengthLEB128(size);
+    });
+    const coreModules = componentMetadata
+      .filter(({ metaType }) => metaType.tag === "module");
 
+    // log number of core Wasm modules to be run with wasm-opt
     let completed = 0;
-    const spinnerText = () => c`{cyan ${completed} / ${coreModules.length}} Running Binaryen on WebAssembly Component Internal Core Modules \n`;
+    const spinnerText = () =>
+      c`{cyan ${completed} / ${coreModules.length}} Running Binaryen on WebAssembly Component Internal Core Modules \n`;
     if (showSpinner) {
       spinner = ora({
-        color: 'cyan',
-        spinner: 'bouncingBar'
+        color: "cyan",
+        spinner: "bouncingBar",
       }).start();
       spinner.text = spinnerText();
     }
 
-    const optimizedCoreModules = await Promise.all(coreModules.map(async ([coreModuleStart, coreModuleEnd]) => {
-      const optimized = wasmOpt(componentBytes.subarray(coreModuleStart, coreModuleEnd), opts?.optArgs);
-      if (spinner) {
-        completed++;
-        spinner.text = spinnerText();
+    // gather the options for wasm-opt. optionally, adding the asyncify flag
+    const args = opts?.optArgs ?
+      [...opts.optArgs] :
+      ['-Oz', '--low-memory-unused', '--enable-bulk-memory', '--strip-debug'];
+    if (opts?.asyncify) args.push('--asyncify');
+
+
+    // process core Wasm modules with wasm-opt
+    await Promise.all(
+      coreModules.map(async (metadata) => {
+        if (metadata.metaType.tag === "module") {
+          // store the wasm-opt processed module in the metadata 
+          metadata.optimized = await wasmOpt(
+            componentBytes.subarray(metadata.range[0], metadata.range[1]),
+            args);
+
+          // compute the size change, including the change to
+          // the LEB128 encoding of the size change
+          const prevModuleSize = metadata.range[1] - metadata.range[0];
+          const newModuleSize = metadata.optimized.byteLength;
+          metadata.newLEBLen = byteLengthLEB128(newModuleSize);
+          metadata.sizeChange = newModuleSize - prevModuleSize;
+
+          if (spinner) {
+            completed++;
+            spinner.text = spinnerText();
+          }
+        }
+      }));
+
+    // organize components in modules into tree parent and children
+    const nodes = componentMetadata.slice(1);
+    const getChildren = (parentIndex) => {
+      const children = [];
+      for (let i = 0; i < nodes.length; i++) {
+        const metadata = nodes[i];
+        if (metadata.parentIndex === parentIndex) {
+          nodes.splice(i, 1); // remove from nodes
+          i--;
+          metadata.children = getChildren(metadata.index);
+          metadata.sizeChange = metadata.children
+            .reduce((total, {prevLEBLen, newLEBLen, sizeChange}) => {
+              return sizeChange ?
+                total + sizeChange + newLEBLen - prevLEBLen :
+                total;
+            },
+            metadata.sizeChange || 0);
+          const prevSize = metadata.range[1] - metadata.range[0];
+          metadata.newLEBLen = byteLengthLEB128(prevSize + metadata.sizeChange);
+          children.push(metadata);
+        }
       }
-      return optimized;
-    }));
+      return children;
+    };
+    const componentTree = getChildren(0);
 
-    let outComponentBytes = new Uint8Array(componentBytes.byteLength);
-    let nextReadPos = 0, nextWritePos = 0;
-    for (let i = 0; i < coreModules.length; i++) {
-      const [coreModuleStart, coreModuleEnd] = coreModules[i];
-      const optimizedCoreModule = optimizedCoreModules[i];
+    // compute the total size change in the component binary
+    const sizeChange = componentTree
+      .reduce((total, {prevLEBLen, newLEBLen, sizeChange}) => {
+        return total + (sizeChange || 0) + newLEBLen - prevLEBLen;
+      }, 0);
 
-      let lebByteLen = 1;
-      while (componentBytes[coreModuleStart - 1 - lebByteLen] & 0x80) lebByteLen++;
+    let outComponentBytes = new Uint8Array(
+      componentBytes.byteLength + sizeChange);
+    let nextReadPos = 0, nextWritePos = 0;
 
-      // Write from the last read to the LEB byte start of the core module
-      outComponentBytes.set(componentBytes.subarray(nextReadPos, coreModuleStart - lebByteLen), nextWritePos);
-      nextWritePos += coreModuleStart - lebByteLen - nextReadPos;
+    const write = ({prevLEBLen, range, optimized, children, sizeChange}) => {
+      // write from the last read to the LEB byte start
+      outComponentBytes.set(
+        componentBytes.subarray(nextReadPos, range[0] - prevLEBLen),
+        nextWritePos
+      );
+      nextWritePos += range[0] - prevLEBLen - nextReadPos;
 
-      // Write the new LEB bytes
-      let val = optimizedCoreModule.byteLength;
+      // write the new LEB bytes
+      let val = range[1] - range[0] + sizeChange;
       do {
-        const byte = val & 0x7F;
+        const byte = val & 0x7f;
         val >>>= 7;
         outComponentBytes[nextWritePos++] = val === 0 ? byte : byte | 0x80;
       } while (val !== 0);
 
-      // Write the core module
-      outComponentBytes.set(optimizedCoreModule, nextWritePos);
-      nextWritePos += optimizedCoreModule.byteLength;
-
-      nextReadPos = coreModuleEnd;
-    }
+      if (optimized) {
+        // write the core module
+        outComponentBytes.set(optimized, nextWritePos);
+        nextReadPos = range[1];
+        nextWritePos += optimized.byteLength;
+      } else if (children.length > 0) {
+        // write child components / modules
+        nextReadPos = range[0];
+        children.forEach(write);
+      } else {
+        // write component
+        outComponentBytes.set(
+          componentBytes.subarray(range[0], range[1]),
+          nextWritePos
+        );
+        nextReadPos = range[1];
+        nextWritePos += range[1] - range[0];
+      }
+    };
 
-    outComponentBytes.set(componentBytes.subarray(nextReadPos, componentBytes.byteLength), nextWritePos);
-    nextWritePos += componentBytes.byteLength - nextReadPos;
-    nextReadPos += componentBytes.byteLength - nextReadPos;
+    // write each top-level component / module
+    componentTree.forEach(write);
 
-    outComponentBytes = outComponentBytes.subarray(0, outComponentBytes.length + nextWritePos - nextReadPos);
+    // write remaining
+    outComponentBytes.set(
+      componentBytes.subarray(nextReadPos),
+      nextWritePos
+    );
 
     // verify it still parses ok
-    try {
-      await print(outComponentBytes);
-    } catch (e) {
-      throw new Error(`Internal error performing optimization.\n${e.message}`)
+    if (!opts?.noVerify) {
+      try {
+        await print(outComponentBytes);
+      } catch (e) {
+        throw new Error(
+          `Internal error performing optimization.\n${e.message}`
+        );
+      }
     }
 
     return {
       component: outComponentBytes,
-      compressionInfo: coreModules.map(([s, e], i) => ({ beforeBytes: e - s, afterBytes: optimizedCoreModules[i].byteLength }))
+      compressionInfo: coreModules.map(({range, optimized}) => ({
+        beforeBytes: range[1] - range[0],
+        afterBytes: optimized?.byteLength,
+      })),
     };
-  }
-  finally {
-    if (spinner)
-      spinner.stop();
+  } finally {
+    if (spinner) spinner.stop();
   }
 }
 
 /**
- * @param {Uint8Array} source 
+ * @param {Uint8Array} source
+ * @param {Array<string>} args
  * @returns {Promise<Uint8Array>}
  */
-async function wasmOpt(source, args = ['-O1', '--low-memory-unused', '--enable-bulk-memory']) {
-  const wasmOptPath = fileURLToPath(import.meta.resolve('binaryen/bin/wasm-opt'));
+async function wasmOpt(source, args) {
+  const wasmOptPath = fileURLToPath(
+    import.meta.resolve("binaryen/bin/wasm-opt")
+  );
 
   try {
-    return await spawnIOTmp(wasmOptPath, source, [
-      ...args, '-o'
-    ]);
+    return await spawnIOTmp(wasmOptPath, source, [...args, "-o"]);
   } catch (e) {
-    if (e.toString().includes('BasicBlock requested'))
+    if (e.toString().includes("BasicBlock requested"))
       return wasmOpt(source, args);
     throw e;
   }

package/src/cmd/run.js

@@ -40,8 +40,8 @@ export async function serve (componentPath, args, opts) {
   return runComponent(componentPath, args, opts, `
     import { HTTPServer } from '@bytecodealliance/preview2-shim/http';
     const server = new HTTPServer(mod.incomingHandler);
-    ${tryFindPort ? `
     let port = ${port};
+    ${tryFindPort ? `
     while (true) {
       try {
         server.listen(port, ${JSON.stringify(host)});
@@ -52,8 +52,8 @@ export async function serve (componentPath, args, opts) {
       }
       port++;
     }
-    ` : `server.listen(${port}, ${JSON.stringify(host)})`}
-    console.error(\`Server listening on \${port}...\`);
+    ` : `server.listen(port, ${JSON.stringify(host)})`}
+    console.error(\`Server listening on port...\`);
   `);
 }
 

package/src/cmd/transpile.d.ts

@@ -1,4 +1,5 @@
 export function types(witPath: any, opts: any): Promise<void>;
+export function guestTypes(witPath: any, opts: any): Promise<void>;
 /**
  * @param {string} witPath
  * @param {{
@@ -6,8 +7,12 @@ export function types(witPath: any, opts: any): Promise<void>;
  *   worldName?: string,
  *   instantiation?: 'async' | 'sync',
  *   tlaCompat?: bool,
+ *   asyncMode?: string,
+ *   asyncImports?: string[],
+ *   asyncExports?: string[],
  *   outDir?: string,
  *   features?: string[] | 'all',
+ *   guest?: bool,
  * }} opts
  * @returns {Promise<{ [filename: string]: Uint8Array }>}
  */
@@ -16,8 +21,12 @@ export function typesComponent(witPath: string, opts: {
     worldName?: string;
     instantiation?: "async" | "sync";
     tlaCompat?: bool;
+    asyncMode?: string;
+    asyncImports?: string[];
+    asyncExports?: string[];
     outDir?: string;
     features?: string[] | "all";
+    guest?: bool;
 }): Promise<{
     [filename: string]: Uint8Array;
 }>;
@@ -30,6 +39,9 @@ export function transpile(componentPath: any, opts: any, program: any): Promise<
  *   instantiation?: 'async' | 'sync',
  *   importBindings?: 'js' | 'optimized' | 'hybrid' | 'direct-optimized',
  *   map?: Record<string, string>,
+ *   asyncMode?: string,
+ *   asyncImports?: string[],
+ *   asyncExports?: string[],
  *   validLiftingOptimization?: bool,
  *   tracing?: bool,
  *   nodejsCompat?: bool,
@@ -51,6 +63,9 @@ export function transpileComponent(component: Uint8Array, opts?: {
     instantiation?: "async" | "sync";
     importBindings?: "js" | "optimized" | "hybrid" | "direct-optimized";
     map?: Record<string, string>;
+    asyncMode?: string;
+    asyncImports?: string[];
+    asyncExports?: string[];
     validLiftingOptimization?: bool;
     tracing?: bool;
     nodejsCompat?: bool;

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

@@ -1 +1 @@
-{"version":3,"file":"transpile.d.ts","sourceRoot":"","sources":["transpile.js"],"names":[],"mappings":"AAgBA,8DAGC;AAED;;;;;;;;;;;GAWG;AACH,wCAXW,MAAM,QACN;IACV,IAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAiB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACrC,SAAa,CAAC,EAAE,IAAI,CAAC;IACrB,MAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAY,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;CAC7B,GACS,OAAO,CAAC;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC,CA6BvD;AAkBD,sFAwBC;AAkBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,8CAtBW,UAAU,SACV;IACV,IAAQ,EAAE,MAAM,CAAC;IACjB,aAAiB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACrC,cAAkB,CAAC,EAAE,IAAI,GAAG,WAAW,GAAG,QAAQ,GAAG,kBAAkB,CAAC;IACxE,GAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,wBAA4B,CAAC,EAAE,IAAI,CAAC;IACpC,OAAW,CAAC,EAAE,IAAI,CAAC;IACnB,YAAgB,CAAC,EAAE,IAAI,CAAC;IACxB,SAAa,CAAC,EAAE,IAAI,CAAC;IACrB,YAAgB,CAAC,EAAE,IAAI,CAAC;IACxB,EAAM,CAAC,EAAE,IAAI,CAAC;IACd,MAAU,CAAC,EAAE,IAAI,CAAC;IAClB,QAAY,CAAC,EAAE,IAAI,CAAC;IACpB,iBAAqB,CAAC,EAAE,IAAI,CAAC;IAC7B,MAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAe,CAAC,EAAE,IAAI,CAAC;IACvB,sBAA0B,CAAC,EAAE,IAAI,CAAC;IAClC,OAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB,GACS,OAAO,CAAC;IAAE,KAAK,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC,EAAE,CAAA;CAAE,CAAC,CAoSnI"}
+{"version":3,"file":"transpile.d.ts","sourceRoot":"","sources":["transpile.js"],"names":[],"mappings":"AAgCA,8DAGC;AAED,mEAGC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wCAfW,MAAM,QACN;IACN,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACjC,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAC5B,KAAK,CAAC,EAAE,IAAI,CAAC;CACd,GACS,OAAO,CAAC;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC,CA8CvD;AAkBD,sFA8BC;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,8CAzBW,UAAU,SACV;IACN,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACjC,cAAc,CAAC,EAAE,IAAI,GAAG,WAAW,GAAG,QAAQ,GAAG,kBAAkB,CAAC;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,wBAAwB,CAAC,EAAE,IAAI,CAAC;IAChC,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,EAAE,CAAC,EAAE,IAAI,CAAC;IACV,MAAM,CAAC,EAAE,IAAI,CAAC;IACd,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,iBAAiB,CAAC,EAAE,IAAI,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,sBAAsB,CAAC,EAAE,IAAI,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB,GACS,OAAO,CAAC;IAAE,KAAK,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC,EAAE,CAAA;CAAE,CAAC,CAgTnI"}

package/src/cmd/transpile.js

@@ -14,6 +14,22 @@ 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",
+];
+
+const ASYNC_WASI_EXPORTS = [
+  "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');
@@ -31,6 +47,9 @@ export async function guestTypes (witPath, opts) {
  *   worldName?: string,
  *   instantiation?: 'async' | 'sync',
  *   tlaCompat?: bool,
+ *   asyncMode?: string,
+ *   asyncImports?: string[],
+ *   asyncExports?: string[],
  *   outDir?: string,
  *   features?: string[] | 'all',
  *   guest?: bool,
@@ -57,6 +76,21 @@ export async function typesComponent (witPath, opts) {
     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,
@@ -64,6 +98,7 @@ export async function typesComponent (witPath, opts) {
     world: opts.worldName,
     features,
     guest: opts.guest ?? false,
+    asyncMode,
   }).map(([name, file]) => [`${outDir}${name}`, file]));
 }
 
@@ -105,6 +140,12 @@ export async function transpile (componentPath, opts, program) {
     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');
 }
@@ -133,6 +174,9 @@ async function wasm2Js (source) {
  *   instantiation?: 'async' | 'sync',
  *   importBindings?: 'js' | 'optimized' | 'hybrid' | 'direct-optimized',
  *   map?: Record<string, string>,
+ *   asyncMode?: string,
+ *   asyncImports?: string[],
+ *   asyncExports?: string[],
  *   validLiftingOptimization?: bool,
  *   tracing?: bool,
  *   nodejsCompat?: bool,
@@ -155,6 +199,7 @@ export async function transpileComponent (component, opts = {}) {
 
   let spinner;
   const showSpinner = getShowSpinner();
+
   if (opts.optimize) {
     if (showSpinner) setShowSpinner(true);
     ({ component } = await optimizeComponent(component, opts));
@@ -183,10 +228,21 @@ export async function transpileComponent (component, opts = {}) {
     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,

package/src/jco.js

@@ -52,6 +52,11 @@ program.command('transpile')
   .option('--no-typescript', 'do not output TypeScript .d.ts types')
   .option('--valid-lifting-optimization', 'optimize component binary validations assuming all lifted values are valid')
   .addOption(new Option('--import-bindings [mode]', 'bindings mode for imports').choices(['js', 'optimized', 'hybrid', 'direct-optimized']).preset('js'))
+  .addOption(new Option('--async-mode [mode]', 'EXPERIMENTAL: use async imports and exports').choices(['sync', 'jspi']).preset('sync'))
+  .option('--async-wasi-imports', 'EXPERIMENTAL: async component imports from WASI interfaces')
+  .option('--async-wasi-exports', 'EXPERIMENTAL: async component exports from WASI interfaces')
+  .option('--async-imports <imports...>', 'EXPERIMENTAL: async component imports (examples: "wasi:io/poll@0.2.0#poll", "wasi:io/poll#[method]pollable.block")')
+  .option('--async-exports <exports...>', 'EXPERIMENTAL: async component exports (examples: "wasi:cli/run@#run", "handle")')
   .option('--tracing', 'emit `tracing` calls on function entry/exit')
   .option('-b, --base64-cutoff <bytes>', 'set the byte size under which core Wasm binaries will be inlined as base64', myParseInt)
   .option('--tla-compat', 'enables compatibility for JS environments without top-level await support via an async $init promise export')
@@ -76,6 +81,11 @@ program.command('types')
   .requiredOption('-o, --out-dir <out-dir>', 'output directory')
   .option('--tla-compat', 'generates types for the TLA compat output with an async $init promise export')
   .addOption(new Option('-I, --instantiation [mode]', 'type output for custom module instantiation').choices(['async', 'sync']).preset('async'))
+  .addOption(new Option('--async-mode [mode]', 'EXPERIMENTAL: use async imports and exports').choices(['sync', 'jspi']).preset('sync'))
+  .option('--async-wasi-imports', 'EXPERIMENTAL: async component imports from WASI interfaces')
+  .option('--async-wasi-exports', 'EXPERIMENTAL: async component exports from WASI interfaces')
+  .option('--async-imports <imports...>', 'EXPERIMENTAL: async component imports (examples: "wasi:io/poll@0.2.0#poll", "wasi:io/poll#[method]pollable.block")')
+  .option('--async-exports <exports...>', 'EXPERIMENTAL: async component exports (examples: "wasi:cli/run@#run", "handle")')
   .option('-q, --quiet', 'disable output summary')
   .option('--feature <feature>', 'enable one specific WIT feature (repeatable)', collectOptions, [])
   .option('--all-features', 'enable all features')
@@ -144,6 +154,7 @@ program.command('opt')
   .usage('<component-file> -o <output-file>')
   .argument('<component-file>', 'Wasm component binary filepath')
   .requiredOption('-o, --output <output-file>', 'optimized component output filepath')
+  .option('--asyncify', 'runs Asyncify pass in wasm-opt')
   .option('-q, --quiet')
   .option('--', 'custom wasm-opt arguments (defaults to best size optimization)')
   .action(asyncAction(opt));