@bytecodealliance/jco 1.4.0 → 1.4.1

package/obj/interfaces/local-wasm-tools-tools.d.ts

@@ -1,10 +1,10 @@
 export namespace LocalWasmToolsTools {
   export function parse(wat: string): Uint8Array;
   export function print(binary: Uint8Array): string;
-  export function componentNew(binary: Uint8Array, adapters: [string, Uint8Array][] | undefined): Uint8Array;
+  export function componentNew(binary: Uint8Array, adapters: Array<[string, Uint8Array]> | undefined): Uint8Array;
   export function componentWit(binary: Uint8Array): string;
   export function componentEmbed(embedOpts: EmbedOpts): Uint8Array;
-  export function metadataShow(binary: Uint8Array): ModuleMetadata[];
+  export function metadataShow(binary: Uint8Array): Array<ModuleMetadata>;
   export function metadataAdd(binary: Uint8Array, metadata: ProducersFields): Uint8Array;
 }
 /**
@@ -17,7 +17,15 @@ export namespace LocalWasmToolsTools {
  * ## `"compact-utf16"`
  */
 export type StringEncoding = 'utf8' | 'utf16' | 'compact-utf16';
-export type ProducersFields = [string, [string, string][]][];
+export type ProducersFields = Array<[string, Array<[string, string]>]>;
+export type EnabledFeatureSet = EnabledFeatureSetList | EnabledFeatureSetAll;
+export interface EnabledFeatureSetList {
+  tag: 'list',
+  val: Array<string>,
+}
+export interface EnabledFeatureSetAll {
+  tag: 'all',
+}
 export interface EmbedOpts {
   binary?: Uint8Array,
   witSource?: string,
@@ -26,6 +34,7 @@ export interface EmbedOpts {
   dummy?: boolean,
   world?: string,
   metadata?: ProducersFields,
+  features?: EnabledFeatureSet,
 }
 export type ModuleMetaType = ModuleMetaTypeModule | ModuleMetaTypeComponent;
 export interface ModuleMetaTypeModule {

package/obj/interfaces/wasi-cli-environment.d.ts

@@ -1,3 +1,3 @@
 export namespace WasiCliEnvironment {
-  export function getEnvironment(): [string, string][];
+  export function getEnvironment(): Array<[string, string]>;
 }

package/obj/interfaces/wasi-filesystem-preopens.d.ts

@@ -1,5 +1,5 @@
 export namespace WasiFilesystemPreopens {
-  export function getDirectories(): [Descriptor, string][];
+  export function getDirectories(): Array<[Descriptor, string]>;
 }
 import type { Descriptor } from './wasi-filesystem-types.js';
 export { Descriptor };

package/obj/js-component-bindgen-component.d.ts

@@ -1,5 +1,5 @@
-export type Files = [string, Uint8Array][];
-export type Maps = [string, string][];
+export type Files = Array<[string, Uint8Array]>;
+export type Maps = Array<[string, string]>;
 export type InstantiationMode = InstantiationModeAsync | InstantiationModeSync;
 export interface InstantiationModeAsync {
   tag: 'async',
@@ -48,12 +48,21 @@ export interface WitPath {
   tag: 'path',
   val: string,
 }
+export type EnabledFeatureSet = EnabledFeatureSetList | EnabledFeatureSetAll;
+export interface EnabledFeatureSetList {
+  tag: 'list',
+  val: Array<string>,
+}
+export interface EnabledFeatureSetAll {
+  tag: 'all',
+}
 export interface TypeGenerationOptions {
   wit: Wit,
   world?: string,
   tlaCompat?: boolean,
   instantiation?: InstantiationMode,
   map?: Maps,
+  features?: EnabledFeatureSet,
 }
 /**
 * # Variants
@@ -65,8 +74,8 @@ export interface TypeGenerationOptions {
 export type ExportType = 'function' | 'instance';
 export interface Transpiled {
   files: Files,
-  imports: string[],
-  exports: [string, ExportType][],
+  imports: Array<string>,
+  exports: Array<[string, ExportType]>,
 }
 import { WasiCliEnvironment } from './interfaces/wasi-cli-environment.js';
 import { WasiCliExit } from './interfaces/wasi-cli-exit.js';

package/obj/js-component-bindgen-component.js

@@ -3792,169 +3792,186 @@ function generate(arg0, arg1) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn0(ret);
   if (variant31.tag === 'err') {
     throw new ComponentError(variant31.val);
   }
-  return variant31.val;
+  const retVal = variant31.val;
+  postReturn0(ret);
+  return retVal;
 }
 
 function generateTypes(arg0, arg1) {
   if (!_initialized) throwUninitialized();
-  var ptr0 = utf8Encode(arg0, realloc1, memory0);
-  var len0 = utf8EncodedLen;
-  var {wit: v1_0, world: v1_1, tlaCompat: v1_2, instantiation: v1_3, map: v1_4 } = arg1;
-  var variant5 = v1_0;
-  let variant5_0;
-  let variant5_1;
-  let variant5_2;
-  switch (variant5.tag) {
+  var ptr0 = realloc1(0, 0, 4, 64);
+  var ptr1 = utf8Encode(arg0, realloc1, memory0);
+  var len1 = utf8EncodedLen;
+  dataView(memory0).setInt32(ptr0 + 4, len1, true);
+  dataView(memory0).setInt32(ptr0 + 0, ptr1, true);
+  var {wit: v2_0, world: v2_1, tlaCompat: v2_2, instantiation: v2_3, map: v2_4, features: v2_5 } = arg1;
+  var variant6 = v2_0;
+  switch (variant6.tag) {
     case 'source': {
-      const e = variant5.val;
-      var ptr2 = utf8Encode(e, realloc1, memory0);
-      var len2 = utf8EncodedLen;
-      variant5_0 = 0;
-      variant5_1 = ptr2;
-      variant5_2 = len2;
+      const e = variant6.val;
+      dataView(memory0).setInt8(ptr0 + 8, 0, true);
+      var ptr3 = utf8Encode(e, realloc1, memory0);
+      var len3 = utf8EncodedLen;
+      dataView(memory0).setInt32(ptr0 + 16, len3, true);
+      dataView(memory0).setInt32(ptr0 + 12, ptr3, true);
       break;
     }
     case 'binary': {
-      const e = variant5.val;
-      var val3 = e;
-      var len3 = val3.byteLength;
-      var ptr3 = realloc1(0, 0, 1, len3 * 1);
-      var src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
-      (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
-      variant5_0 = 1;
-      variant5_1 = ptr3;
-      variant5_2 = len3;
+      const e = variant6.val;
+      dataView(memory0).setInt8(ptr0 + 8, 1, true);
+      var val4 = e;
+      var len4 = val4.byteLength;
+      var ptr4 = realloc1(0, 0, 1, len4 * 1);
+      var src4 = new Uint8Array(val4.buffer || val4, val4.byteOffset, len4 * 1);
+      (new Uint8Array(memory0.buffer, ptr4, len4 * 1)).set(src4);
+      dataView(memory0).setInt32(ptr0 + 16, len4, true);
+      dataView(memory0).setInt32(ptr0 + 12, ptr4, true);
       break;
     }
     case 'path': {
-      const e = variant5.val;
-      var ptr4 = utf8Encode(e, realloc1, memory0);
-      var len4 = utf8EncodedLen;
-      variant5_0 = 2;
-      variant5_1 = ptr4;
-      variant5_2 = len4;
+      const e = variant6.val;
+      dataView(memory0).setInt8(ptr0 + 8, 2, true);
+      var ptr5 = utf8Encode(e, realloc1, memory0);
+      var len5 = utf8EncodedLen;
+      dataView(memory0).setInt32(ptr0 + 16, len5, true);
+      dataView(memory0).setInt32(ptr0 + 12, ptr5, true);
       break;
     }
     default: {
-      throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`Wit\``);
+      throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant6.tag)}\` (received \`${variant6}\`) specified for \`Wit\``);
     }
   }
-  var variant7 = v1_1;
-  let variant7_0;
-  let variant7_1;
-  let variant7_2;
-  if (variant7 === null || variant7=== undefined) {
-    variant7_0 = 0;
-    variant7_1 = 0;
-    variant7_2 = 0;
-  } else {
-    const e = variant7;
-    var ptr6 = utf8Encode(e, realloc1, memory0);
-    var len6 = utf8EncodedLen;
-    variant7_0 = 1;
-    variant7_1 = ptr6;
-    variant7_2 = len6;
-  }
-  var variant8 = v1_2;
-  let variant8_0;
-  let variant8_1;
+  var variant8 = v2_1;
   if (variant8 === null || variant8=== undefined) {
-    variant8_0 = 0;
-    variant8_1 = 0;
+    dataView(memory0).setInt8(ptr0 + 20, 0, true);
   } else {
     const e = variant8;
-    variant8_0 = 1;
-    variant8_1 = e ? 1 : 0;
+    dataView(memory0).setInt8(ptr0 + 20, 1, true);
+    var ptr7 = utf8Encode(e, realloc1, memory0);
+    var len7 = utf8EncodedLen;
+    dataView(memory0).setInt32(ptr0 + 28, len7, true);
+    dataView(memory0).setInt32(ptr0 + 24, ptr7, true);
+  }
+  var variant9 = v2_2;
+  if (variant9 === null || variant9=== undefined) {
+    dataView(memory0).setInt8(ptr0 + 32, 0, true);
+  } else {
+    const e = variant9;
+    dataView(memory0).setInt8(ptr0 + 32, 1, true);
+    dataView(memory0).setInt8(ptr0 + 33, e ? 1 : 0, true);
   }
-  var variant10 = v1_3;
-  let variant10_0;
-  let variant10_1;
-  if (variant10 === null || variant10=== undefined) {
-    variant10_0 = 0;
-    variant10_1 = 0;
+  var variant11 = v2_3;
+  if (variant11 === null || variant11=== undefined) {
+    dataView(memory0).setInt8(ptr0 + 34, 0, true);
   } else {
-    const e = variant10;
-    var variant9 = e;
-    let variant9_0;
-    switch (variant9.tag) {
+    const e = variant11;
+    dataView(memory0).setInt8(ptr0 + 34, 1, true);
+    var variant10 = e;
+    switch (variant10.tag) {
       case 'async': {
-        variant9_0 = 0;
+        dataView(memory0).setInt8(ptr0 + 35, 0, true);
         break;
       }
       case 'sync': {
-        variant9_0 = 1;
+        dataView(memory0).setInt8(ptr0 + 35, 1, true);
         break;
       }
       default: {
-        throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant9.tag)}\` (received \`${variant9}\`) specified for \`InstantiationMode\``);
+        throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant10.tag)}\` (received \`${variant10}\`) specified for \`InstantiationMode\``);
       }
     }
-    variant10_0 = 1;
-    variant10_1 = variant9_0;
   }
-  var variant15 = v1_4;
-  let variant15_0;
-  let variant15_1;
-  let variant15_2;
-  if (variant15 === null || variant15=== undefined) {
-    variant15_0 = 0;
-    variant15_1 = 0;
-    variant15_2 = 0;
+  var variant16 = v2_4;
+  if (variant16 === null || variant16=== undefined) {
+    dataView(memory0).setInt8(ptr0 + 36, 0, true);
   } else {
-    const e = variant15;
-    var vec14 = e;
-    var len14 = vec14.length;
-    var result14 = realloc1(0, 0, 4, len14 * 16);
-    for (let i = 0; i < vec14.length; i++) {
-      const e = vec14[i];
-      const base = result14 + i * 16;var [tuple11_0, tuple11_1] = e;
-      var ptr12 = utf8Encode(tuple11_0, realloc1, memory0);
-      var len12 = utf8EncodedLen;
-      dataView(memory0).setInt32(base + 4, len12, true);
-      dataView(memory0).setInt32(base + 0, ptr12, true);
-      var ptr13 = utf8Encode(tuple11_1, realloc1, memory0);
+    const e = variant16;
+    dataView(memory0).setInt8(ptr0 + 36, 1, true);
+    var vec15 = e;
+    var len15 = vec15.length;
+    var result15 = realloc1(0, 0, 4, len15 * 16);
+    for (let i = 0; i < vec15.length; i++) {
+      const e = vec15[i];
+      const base = result15 + i * 16;var [tuple12_0, tuple12_1] = e;
+      var ptr13 = utf8Encode(tuple12_0, realloc1, memory0);
       var len13 = utf8EncodedLen;
-      dataView(memory0).setInt32(base + 12, len13, true);
-      dataView(memory0).setInt32(base + 8, ptr13, true);
+      dataView(memory0).setInt32(base + 4, len13, true);
+      dataView(memory0).setInt32(base + 0, ptr13, true);
+      var ptr14 = utf8Encode(tuple12_1, realloc1, memory0);
+      var len14 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 12, len14, true);
+      dataView(memory0).setInt32(base + 8, ptr14, true);
+    }
+    dataView(memory0).setInt32(ptr0 + 44, len15, true);
+    dataView(memory0).setInt32(ptr0 + 40, result15, true);
+  }
+  var variant20 = v2_5;
+  if (variant20 === null || variant20=== undefined) {
+    dataView(memory0).setInt8(ptr0 + 48, 0, true);
+  } else {
+    const e = variant20;
+    dataView(memory0).setInt8(ptr0 + 48, 1, true);
+    var variant19 = e;
+    switch (variant19.tag) {
+      case 'list': {
+        const e = variant19.val;
+        dataView(memory0).setInt8(ptr0 + 52, 0, true);
+        var vec18 = e;
+        var len18 = vec18.length;
+        var result18 = realloc1(0, 0, 4, len18 * 8);
+        for (let i = 0; i < vec18.length; i++) {
+          const e = vec18[i];
+          const base = result18 + i * 8;var ptr17 = utf8Encode(e, realloc1, memory0);
+          var len17 = utf8EncodedLen;
+          dataView(memory0).setInt32(base + 4, len17, true);
+          dataView(memory0).setInt32(base + 0, ptr17, true);
+        }
+        dataView(memory0).setInt32(ptr0 + 60, len18, true);
+        dataView(memory0).setInt32(ptr0 + 56, result18, true);
+        break;
+      }
+      case 'all': {
+        dataView(memory0).setInt8(ptr0 + 52, 1, true);
+        break;
+      }
+      default: {
+        throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant19.tag)}\` (received \`${variant19}\`) specified for \`EnabledFeatureSet\``);
+      }
     }
-    variant15_0 = 1;
-    variant15_1 = result14;
-    variant15_2 = len14;
   }
-  const ret = exports1['generate-types'](ptr0, len0, variant5_0, variant5_1, variant5_2, variant7_0, variant7_1, variant7_2, variant8_0, variant8_1, variant10_0, variant10_1, variant15_0, variant15_1, variant15_2);
-  let variant20;
+  const ret = exports1['generate-types'](ptr0);
+  let variant25;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      var len18 = dataView(memory0).getInt32(ret + 8, true);
-      var base18 = dataView(memory0).getInt32(ret + 4, true);
-      var result18 = [];
-      for (let i = 0; i < len18; i++) {
-        const base = base18 + i * 16;
-        var ptr16 = dataView(memory0).getInt32(base + 0, true);
-        var len16 = dataView(memory0).getInt32(base + 4, true);
-        var result16 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr16, len16));
-        var ptr17 = dataView(memory0).getInt32(base + 8, true);
-        var len17 = dataView(memory0).getInt32(base + 12, true);
-        var result17 = new Uint8Array(memory0.buffer.slice(ptr17, ptr17 + len17 * 1));
-        result18.push([result16, result17]);
+      var len23 = dataView(memory0).getInt32(ret + 8, true);
+      var base23 = dataView(memory0).getInt32(ret + 4, true);
+      var result23 = [];
+      for (let i = 0; i < len23; i++) {
+        const base = base23 + i * 16;
+        var ptr21 = dataView(memory0).getInt32(base + 0, true);
+        var len21 = dataView(memory0).getInt32(base + 4, true);
+        var result21 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr21, len21));
+        var ptr22 = dataView(memory0).getInt32(base + 8, true);
+        var len22 = dataView(memory0).getInt32(base + 12, true);
+        var result22 = new Uint8Array(memory0.buffer.slice(ptr22, ptr22 + len22 * 1));
+        result23.push([result21, result22]);
       }
-      variant20= {
+      variant25= {
         tag: 'ok',
-        val: result18
+        val: result23
       };
       break;
     }
     case 1: {
-      var ptr19 = dataView(memory0).getInt32(ret + 4, true);
-      var len19 = dataView(memory0).getInt32(ret + 8, true);
-      var result19 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr19, len19));
-      variant20= {
+      var ptr24 = dataView(memory0).getInt32(ret + 4, true);
+      var len24 = dataView(memory0).getInt32(ret + 8, true);
+      var result24 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr24, len24));
+      variant25= {
         tag: 'err',
-        val: result19
+        val: result24
       };
       break;
     }
@@ -3962,11 +3979,12 @@ function generateTypes(arg0, arg1) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn1(ret);
-  if (variant20.tag === 'err') {
-    throw new ComponentError(variant20.val);
+  if (variant25.tag === 'err') {
+    throw new ComponentError(variant25.val);
   }
-  return variant20.val;
+  const retVal = variant25.val;
+  postReturn1(ret);
+  return retVal;
 }
 
 let _initialized = false;

package/obj/wasm-tools.js

@@ -3587,11 +3587,12 @@ function parse(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn0(ret);
   if (variant3.tag === 'err') {
     throw new ComponentError(variant3.val);
   }
-  return variant3.val;
+  const retVal = variant3.val;
+  postReturn0(ret);
+  return retVal;
 }
 
 function print(arg0) {
@@ -3628,11 +3629,12 @@ function print(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn0(ret);
   if (variant3.tag === 'err') {
     throw new ComponentError(variant3.val);
   }
-  return variant3.val;
+  const retVal = variant3.val;
+  postReturn0(ret);
+  return retVal;
 }
 
 function componentNew(arg0, arg1) {
@@ -3701,11 +3703,12 @@ function componentNew(arg0, arg1) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn0(ret);
   if (variant8.tag === 'err') {
     throw new ComponentError(variant8.val);
   }
-  return variant8.val;
+  const retVal = variant8.val;
+  postReturn0(ret);
+  return retVal;
 }
 
 function componentWit(arg0) {
@@ -3742,17 +3745,18 @@ function componentWit(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn0(ret);
   if (variant3.tag === 'err') {
     throw new ComponentError(variant3.val);
   }
-  return variant3.val;
+  const retVal = variant3.val;
+  postReturn0(ret);
+  return retVal;
 }
 
 function componentEmbed(arg0) {
   if (!_initialized) throwUninitialized();
-  var ptr0 = realloc1(0, 0, 4, 64);
-  var {binary: v1_0, witSource: v1_1, witPath: v1_2, stringEncoding: v1_3, dummy: v1_4, world: v1_5, metadata: v1_6 } = arg0;
+  var ptr0 = realloc1(0, 0, 4, 80);
+  var {binary: v1_0, witSource: v1_1, witPath: v1_2, stringEncoding: v1_3, dummy: v1_4, world: v1_5, metadata: v1_6, features: v1_7 } = arg0;
   var variant3 = v1_0;
   if (variant3 === null || variant3=== undefined) {
     dataView(memory0).setInt8(ptr0 + 0, 0, true);
@@ -3876,26 +3880,60 @@ function componentEmbed(arg0) {
     dataView(memory0).setInt32(ptr0 + 60, len19, true);
     dataView(memory0).setInt32(ptr0 + 56, result19, true);
   }
+  var variant24 = v1_7;
+  if (variant24 === null || variant24=== undefined) {
+    dataView(memory0).setInt8(ptr0 + 64, 0, true);
+  } else {
+    const e = variant24;
+    dataView(memory0).setInt8(ptr0 + 64, 1, true);
+    var variant23 = e;
+    switch (variant23.tag) {
+      case 'list': {
+        const e = variant23.val;
+        dataView(memory0).setInt8(ptr0 + 68, 0, true);
+        var vec22 = e;
+        var len22 = vec22.length;
+        var result22 = realloc1(0, 0, 4, len22 * 8);
+        for (let i = 0; i < vec22.length; i++) {
+          const e = vec22[i];
+          const base = result22 + i * 8;var ptr21 = utf8Encode(e, realloc1, memory0);
+          var len21 = utf8EncodedLen;
+          dataView(memory0).setInt32(base + 4, len21, true);
+          dataView(memory0).setInt32(base + 0, ptr21, true);
+        }
+        dataView(memory0).setInt32(ptr0 + 76, len22, true);
+        dataView(memory0).setInt32(ptr0 + 72, result22, true);
+        break;
+      }
+      case 'all': {
+        dataView(memory0).setInt8(ptr0 + 68, 1, true);
+        break;
+      }
+      default: {
+        throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant23.tag)}\` (received \`${variant23}\`) specified for \`EnabledFeatureSet\``);
+      }
+    }
+  }
   const ret = exports1['local:wasm-tools/tools#component-embed'](ptr0);
-  let variant23;
+  let variant27;
   switch (dataView(memory0).getUint8(ret + 0, true)) {
     case 0: {
-      var ptr21 = dataView(memory0).getInt32(ret + 4, true);
-      var len21 = dataView(memory0).getInt32(ret + 8, true);
-      var result21 = new Uint8Array(memory0.buffer.slice(ptr21, ptr21 + len21 * 1));
-      variant23= {
+      var ptr25 = dataView(memory0).getInt32(ret + 4, true);
+      var len25 = dataView(memory0).getInt32(ret + 8, true);
+      var result25 = new Uint8Array(memory0.buffer.slice(ptr25, ptr25 + len25 * 1));
+      variant27= {
         tag: 'ok',
-        val: result21
+        val: result25
       };
       break;
     }
     case 1: {
-      var ptr22 = dataView(memory0).getInt32(ret + 4, true);
-      var len22 = dataView(memory0).getInt32(ret + 8, true);
-      var result22 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr22, len22));
-      variant23= {
+      var ptr26 = dataView(memory0).getInt32(ret + 4, true);
+      var len26 = dataView(memory0).getInt32(ret + 8, true);
+      var result26 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr26, len26));
+      variant27= {
         tag: 'err',
-        val: result22
+        val: result26
       };
       break;
     }
@@ -3903,11 +3941,12 @@ function componentEmbed(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn0(ret);
-  if (variant23.tag === 'err') {
-    throw new ComponentError(variant23.val);
+  if (variant27.tag === 'err') {
+    throw new ComponentError(variant27.val);
   }
-  return variant23.val;
+  const retVal = variant27.val;
+  postReturn0(ret);
+  return retVal;
 }
 
 function metadataShow(arg0) {
@@ -4012,11 +4051,12 @@ function metadataShow(arg0) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn1(ret);
   if (variant11.tag === 'err') {
     throw new ComponentError(variant11.val);
   }
-  return variant11.val;
+  const retVal = variant11.val;
+  postReturn1(ret);
+  return retVal;
 }
 
 function metadataAdd(arg0, arg1) {
@@ -4081,11 +4121,12 @@ function metadataAdd(arg0, arg1) {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn0(ret);
   if (variant10.tag === 'err') {
     throw new ComponentError(variant10.val);
   }
-  return variant10.val;
+  const retVal = variant10.val;
+  postReturn0(ret);
+  return retVal;
 }
 
 let _initialized = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/jco",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "JavaScript tooling for working with WebAssembly Components",
   "author": "Guy Bedford",
   "bin": {

package/src/cmd/run.js

@@ -1,6 +1,6 @@
 import { getTmpDir } from '../common.js';
 import { transpile } from './transpile.js';
-import { rm, stat, mkdir, writeFile, symlink } from 'node:fs/promises';
+import { rm, mkdir, writeFile, symlink } from 'node:fs/promises';
 import { basename, resolve, extname } from 'node:path';
 import { spawn } from 'node:child_process';
 import process from 'node:process';
@@ -85,21 +85,11 @@ async function runComponent (componentPath, args, opts, executor) {
 
     await writeFile(resolve(outDir, 'package.json'), JSON.stringify({ type: 'module' }));
 
-    let preview2ShimPath = fileURLToPath(new URL('../../node_modules/@bytecodealliance/preview2-shim', import.meta.url));
-    while (true) {
-      try {
-        if ((await stat(preview2ShimPath)).isDirectory()) {
-          break;
-        }
-      }
-      catch {
-        // empty
-      }
-      let len = preview2ShimPath.length;
-      preview2ShimPath = resolve(preview2ShimPath, '..', '..', '..', 'node_modules', '@bytecodealliance', 'preview2-shim');
-      if (preview2ShimPath.length === len) {
-        throw c`Unable to locate the {bold @bytecodealliance/preview2-shim} package, make sure it is installed.`;
-      }
+    let preview2ShimPath
+    try {
+      preview2ShimPath = fileURLToPath(new URL('../..', import.meta.resolve('@bytecodealliance/preview2-shim')));
+    } catch {
+      throw c`Unable to locate the {bold @bytecodealliance/preview2-shim} package, make sure it is installed.`;
     }
 
     const modulesDir = resolve(outDir, 'node_modules', '@bytecodealliance');

package/src/cmd/transpile.d.ts

@@ -7,6 +7,7 @@ export function types(witPath: any, opts: any): Promise<void>;
  *   instantiation?: 'async' | 'sync',
  *   tlaCompat?: bool,
  *   outDir?: string,
+ *   features?: string[] | 'all',
  * }} opts
  * @returns {Promise<{ [filename: string]: Uint8Array }>}
  */
@@ -16,6 +17,7 @@ export function typesComponent(witPath: string, opts: {
     instantiation?: "async" | "sync";
     tlaCompat?: bool;
     outDir?: string;
+    features?: string[] | "all";
 }): Promise<{
     [filename: string]: Uint8Array;
 }>;

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

@@ -1 +1 @@
-{"version":3,"file":"transpile.d.ts","sourceRoot":"","sources":["transpile.js"],"names":[],"mappings":"AAgBA,8DAGC;AAED;;;;;;;;;;GAUG;AACH,wCAVW,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;CACjB,GACS,OAAO,CAAC;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC,CAoBvD;AAkBD,sFAwBC;AAuBD;;;;;;;;;;;;;;;;;;;;;;;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":"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;AAuBD;;;;;;;;;;;;;;;;;;;;;;;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"}

package/src/cmd/transpile.js

@@ -27,6 +27,7 @@ export async function types (witPath, opts) {
  *   instantiation?: 'async' | 'sync',
  *   tlaCompat?: bool,
  *   outDir?: string,
+ *   features?: string[] | 'all',
  * }} opts
  * @returns {Promise<{ [filename: string]: Uint8Array }>}
  */
@@ -42,11 +43,20 @@ export async function typesComponent (witPath, opts) {
   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 };
+  }
+
   return Object.fromEntries(generateTypes(name, {
     wit: { tag: 'path', val: (isWindows ? '//?/' : '') + resolve(witPath) },
     instantiation,
     tlaCompat: opts.tlaCompat ?? false,
-    world: opts.worldName
+    world: opts.worldName,
+    features,
   }).map(([name, file]) => [`${outDir}${name}`, file]));
 }
 
@@ -59,7 +69,7 @@ async function writeFiles(files, summaryTitle) {
     return;
   console.log(c`
   {bold ${summaryTitle}:}
-  
+
 ${table(Object.entries(files).map(([name, source]) => [
     c` - {italic ${name}}  `,
     c`{black.italic ${sizeStr(source.length)}}`

package/src/jco.js

@@ -11,12 +11,22 @@ program
   .name('jco')
   .description(c`{bold jco - WebAssembly JS Component Tools}\n      JS Component Transpilation Bindgen & Wasm Tools for JS`)
   .usage('<command> [options]')
-  .version('1.4.0');
+  .version('1.4.1');
 
 function myParseInt(value) {
   return parseInt(value, 10);
 }
 
+/**
+* Option parsing that allows for collecting repeated arguments
+*
+* @param {string} value - the new value that is added
+* @param {string[]} previous - the existing list of values
+*/
+function collectOptions(value, previous) {
+  return previous.concat([value]);
+}
+
 program.command('componentize')
   .description('Create a component from a JavaScript module')
   .usage('<js-source> --wit wit-world.wit -o <component-path>')
@@ -64,6 +74,8 @@ program.command('types')
   .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'))
   .option('-q, --quiet', 'disable output summary')
+  .option('--feature <feature>', 'enable one specific WIT feature (repeatable)', collectOptions, [])
+  .option('--all-features', 'enable all features')
   .action(asyncAction(types));
 
 program.command('run')