@bytecodealliance/jco 1.17.9-rc.0 → 1.18.0

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

@@ -3,6 +3,7 @@ export function parse(wat: string): Uint8Array;
 export function print(binary: Uint8Array): string;
 export function componentNew(binary: Uint8Array, adapters: Array<[string, Uint8Array]> | undefined): Uint8Array;
 export function componentWit(binary: Uint8Array): string;
+export function componentWitMetadataForWorld(wit: WitSpecifier, worldName: string | undefined): WitMetadata;
 export function componentEmbed(embedOpts: EmbedOpts): Uint8Array;
 export function metadataShow(binary: Uint8Array): Array<ModuleMetadata>;
 export function metadataAdd(binary: Uint8Array, metadata: ProducersFields): Uint8Array;
@@ -16,6 +17,32 @@ export function metadataAdd(binary: Uint8Array, metadata: ProducersFields): Uint
  * ## `"compact-utf16"`
  */
 export type StringEncoding = 'utf8' | 'utf16' | 'compact-utf16';
+export interface SemverVersion {
+  major: bigint,
+  minor: bigint,
+  patch: bigint,
+  pre?: string,
+  build?: string,
+}
+export interface InterfaceMetadata {
+  namespace: string,
+  'package': string,
+  'interface': string,
+  version?: SemverVersion,
+}
+export interface WitMetadata {
+  imports: Array<InterfaceMetadata>,
+  exports: Array<InterfaceMetadata>,
+}
+export type WitSpecifier = WitSpecifierSource | WitSpecifierPath;
+export interface WitSpecifierSource {
+  tag: 'source',
+  val: string,
+}
+export interface WitSpecifierPath {
+  tag: 'path',
+  val: string,
+}
 export type ProducersFields = Array<[string, Array<[string, string]>]>;
 export type EnabledFeatureSet = EnabledFeatureSetList | EnabledFeatureSetAll;
 export interface EnabledFeatureSetList {

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

@@ -1,4 +1,4 @@
-"use jco";
+"use components";
 import { environment, exit as exit$1, stderr, stdin, stdout, terminalInput, terminalOutput, terminalStderr, terminalStdin, terminalStdout } from '@bytecodealliance/preview2-shim/cli';
 import { preopens, types } from '@bytecodealliance/preview2-shim/filesystem';
 import { error, streams } from '@bytecodealliance/preview2-shim/io';

package/obj/wasm-tools.js

@@ -1,4 +1,4 @@
-"use jco";
+"use components";
 import { environment, exit as exit$1, stderr, stdin, stdout, terminalInput, terminalOutput, terminalStderr, terminalStdin, terminalStdout } from '@bytecodealliance/preview2-shim/cli';
 import { preopens, types } from '@bytecodealliance/preview2-shim/filesystem';
 import { error, streams } from '@bytecodealliance/preview2-shim/io';
@@ -9058,6 +9058,8 @@ let postReturn0;
 let postReturn0Async;
 let postReturn1;
 let postReturn1Async;
+let postReturn2;
+let postReturn2Async;
 let toolsParse;
 
 function parse(arg0) {
@@ -9499,6 +9501,289 @@ function componentWit(arg0) {
   
   
   
+  if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+    throw new ComponentError(retCopy.val);
+  }
+  return retCopy.val;
+  
+}
+let toolsComponentWitMetadataForWorld;
+
+function componentWitMetadataForWorld(arg0, arg1) {
+  if (!_initialized) throwUninitialized();
+  var variant2 = arg0;
+  let variant2_0;
+  let variant2_1;
+  let variant2_2;
+  switch (variant2.tag) {
+    case 'source': {
+      const e = variant2.val;
+      
+      var encodeRes = _utf8AllocateAndEncode(e, realloc1, memory0);
+      var ptr0= encodeRes.ptr;
+      var len0 = encodeRes.len;
+      
+      variant2_0 = 0;
+      variant2_1 = ptr0;
+      variant2_2 = len0;
+      break;
+    }
+    case 'path': {
+      const e = variant2.val;
+      
+      var encodeRes = _utf8AllocateAndEncode(e, realloc1, memory0);
+      var ptr1= encodeRes.ptr;
+      var len1 = encodeRes.len;
+      
+      variant2_0 = 1;
+      variant2_1 = ptr1;
+      variant2_2 = len1;
+      break;
+    }
+    default: {
+      throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant2.tag)}\` (received \`${variant2}\`) specified for \`WitSpecifier\``);
+    }
+  }
+  var variant4 = arg1;
+  let variant4_0;
+  let variant4_1;
+  let variant4_2;
+  if (variant4 === null || variant4=== undefined) {
+    variant4_0 = 0;
+    variant4_1 = 0;
+    variant4_2 = 0;
+  } else {
+    const e = variant4;
+    
+    var encodeRes = _utf8AllocateAndEncode(e, realloc1, memory0);
+    var ptr3= encodeRes.ptr;
+    var len3 = encodeRes.len;
+    
+    variant4_0 = 1;
+    variant4_1 = ptr3;
+    variant4_2 = len3;
+  }
+  _debugLog('[iface="local:wasm-tools/tools", function="component-wit-metadata-for-world"][Instruction::CallWasm] enter', {
+    funcName: 'component-wit-metadata-for-world',
+    paramCount: 6,
+    async: false,
+    postReturn: true,
+  });
+  const hostProvided = false;
+  
+  const [task, _wasm_call_currentTaskID] = createNewCurrentTask({
+    componentIdx: 0,
+    isAsync: false,
+    isManualAsync: false,
+    entryFnName: 'toolsComponentWitMetadataForWorld',
+    getCallbackFn: () => null,
+    callbackFnName: 'null',
+    errHandling: 'throw-result-err',
+    callingWasmExport: true,
+  });
+  
+  const started = task.enterSync();
+  task.setReturnMemoryIdx(0);
+  task.setReturnMemory(memory0);
+  let ret =   _withGlobalCurrentTaskMeta({
+    taskID: task.id(),
+    componentIdx: task.componentIdx(),
+    fn: () => toolsComponentWitMetadataForWorld(variant2_0, variant2_1, variant2_2, variant4_0, variant4_1, variant4_2),
+  });
+  
+  let variant24;
+  switch (dataView(memory0).getUint8(ret + 0, true)) {
+    case 0: {
+      var len13 = dataView(memory0).getUint32(ret + 8, true);
+      var base13 = dataView(memory0).getUint32(ret + 4, true);
+      var result13 = [];
+      for (let i = 0; i < len13; i++) {
+        const base = base13 + i * 80;
+        var ptr5 = dataView(memory0).getUint32(base + 0, true);
+        var len5 = dataView(memory0).getUint32(base + 4, true);
+        var result5 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+        var ptr6 = dataView(memory0).getUint32(base + 8, true);
+        var len6 = dataView(memory0).getUint32(base + 12, true);
+        var result6 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+        var ptr7 = dataView(memory0).getUint32(base + 16, true);
+        var len7 = dataView(memory0).getUint32(base + 20, true);
+        var result7 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr7, len7));
+        let variant12;
+        switch (dataView(memory0).getUint8(base + 24, true)) {
+          case 0: {
+            variant12 = undefined;
+            break;
+          }
+          case 1: {
+            let variant9;
+            switch (dataView(memory0).getUint8(base + 56, true)) {
+              case 0: {
+                variant9 = undefined;
+                break;
+              }
+              case 1: {
+                var ptr8 = dataView(memory0).getUint32(base + 60, true);
+                var len8 = dataView(memory0).getUint32(base + 64, true);
+                var result8 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+                variant9 = result8;
+                break;
+              }
+              default: {
+                throw new TypeError('invalid variant discriminant for option');
+              }
+            }
+            let variant11;
+            switch (dataView(memory0).getUint8(base + 68, true)) {
+              case 0: {
+                variant11 = undefined;
+                break;
+              }
+              case 1: {
+                var ptr10 = dataView(memory0).getUint32(base + 72, true);
+                var len10 = dataView(memory0).getUint32(base + 76, true);
+                var result10 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+                variant11 = result10;
+                break;
+              }
+              default: {
+                throw new TypeError('invalid variant discriminant for option');
+              }
+            }
+            variant12 = {
+              major: BigInt.asUintN(64, BigInt(dataView(memory0).getBigInt64(base + 32, true))),
+              minor: BigInt.asUintN(64, BigInt(dataView(memory0).getBigInt64(base + 40, true))),
+              patch: BigInt.asUintN(64, BigInt(dataView(memory0).getBigInt64(base + 48, true))),
+              pre: variant9,
+              build: variant11,
+            };
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        result13.push({
+          namespace: result5,
+          package: result6,
+          interface: result7,
+          version: variant12,
+        });
+      }
+      var len22 = dataView(memory0).getUint32(ret + 16, true);
+      var base22 = dataView(memory0).getUint32(ret + 12, true);
+      var result22 = [];
+      for (let i = 0; i < len22; i++) {
+        const base = base22 + i * 80;
+        var ptr14 = dataView(memory0).getUint32(base + 0, true);
+        var len14 = dataView(memory0).getUint32(base + 4, true);
+        var result14 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr14, len14));
+        var ptr15 = dataView(memory0).getUint32(base + 8, true);
+        var len15 = dataView(memory0).getUint32(base + 12, true);
+        var result15 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr15, len15));
+        var ptr16 = dataView(memory0).getUint32(base + 16, true);
+        var len16 = dataView(memory0).getUint32(base + 20, true);
+        var result16 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr16, len16));
+        let variant21;
+        switch (dataView(memory0).getUint8(base + 24, true)) {
+          case 0: {
+            variant21 = undefined;
+            break;
+          }
+          case 1: {
+            let variant18;
+            switch (dataView(memory0).getUint8(base + 56, true)) {
+              case 0: {
+                variant18 = undefined;
+                break;
+              }
+              case 1: {
+                var ptr17 = dataView(memory0).getUint32(base + 60, true);
+                var len17 = dataView(memory0).getUint32(base + 64, true);
+                var result17 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr17, len17));
+                variant18 = result17;
+                break;
+              }
+              default: {
+                throw new TypeError('invalid variant discriminant for option');
+              }
+            }
+            let variant20;
+            switch (dataView(memory0).getUint8(base + 68, true)) {
+              case 0: {
+                variant20 = undefined;
+                break;
+              }
+              case 1: {
+                var ptr19 = dataView(memory0).getUint32(base + 72, true);
+                var len19 = dataView(memory0).getUint32(base + 76, true);
+                var result19 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr19, len19));
+                variant20 = result19;
+                break;
+              }
+              default: {
+                throw new TypeError('invalid variant discriminant for option');
+              }
+            }
+            variant21 = {
+              major: BigInt.asUintN(64, BigInt(dataView(memory0).getBigInt64(base + 32, true))),
+              minor: BigInt.asUintN(64, BigInt(dataView(memory0).getBigInt64(base + 40, true))),
+              patch: BigInt.asUintN(64, BigInt(dataView(memory0).getBigInt64(base + 48, true))),
+              pre: variant18,
+              build: variant20,
+            };
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        result22.push({
+          namespace: result14,
+          package: result15,
+          interface: result16,
+          version: variant21,
+        });
+      }
+      variant24= {
+        tag: 'ok',
+        val: {
+          imports: result13,
+          exports: result22,
+        }
+      };
+      break;
+    }
+    case 1: {
+      var ptr23 = dataView(memory0).getUint32(ret + 4, true);
+      var len23 = dataView(memory0).getUint32(ret + 8, true);
+      var result23 = TEXT_DECODER_UTF8.decode(new Uint8Array(memory0.buffer, ptr23, len23));
+      variant24= {
+        tag: 'err',
+        val: result23
+      };
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant discriminant for expected');
+    }
+  }
+  _debugLog('[iface="local:wasm-tools/tools", function="component-wit-metadata-for-world"][Instruction::Return]', {
+    funcName: 'component-wit-metadata-for-world',
+    paramCount: 1,
+    async: false,
+    postReturn: true
+  });
+  const retCopy = variant24;
+  task.resolve([retCopy.val]);
+  
+  let cstate = getOrCreateAsyncState(0);
+  cstate.mayLeave = false;
+  postReturn1(ret);
+  cstate.mayLeave = true;
+  task.exit();
+  
+  
+  
   if (typeof retCopy === 'object' && retCopy.tag === 'err') {
     throw new ComponentError(retCopy.val);
   }
@@ -9957,7 +10242,7 @@ function metadataShow(arg0) {
   
   let cstate = getOrCreateAsyncState(0);
   cstate.mayLeave = false;
-  postReturn1(ret);
+  postReturn2(ret);
   cstate.mayLeave = true;
   task.exit();
   
@@ -11897,12 +12182,20 @@ export const $init = (() => {
       postReturn0Async = exports1['cabi_post_local:wasm-tools/tools#component-embed'];
     }
     
-    postReturn1 = exports1['cabi_post_local:wasm-tools/tools#metadata-show'];
+    postReturn1 = exports1['cabi_post_local:wasm-tools/tools#component-wit-metadata-for-world'];
+    
+    try {
+      postReturn1Async = WebAssembly.promising(exports1['cabi_post_local:wasm-tools/tools#component-wit-metadata-for-world']);
+    } catch(err) {
+      postReturn1Async = exports1['cabi_post_local:wasm-tools/tools#component-wit-metadata-for-world'];
+    }
+    
+    postReturn2 = exports1['cabi_post_local:wasm-tools/tools#metadata-show'];
     
     try {
-      postReturn1Async = WebAssembly.promising(exports1['cabi_post_local:wasm-tools/tools#metadata-show']);
+      postReturn2Async = WebAssembly.promising(exports1['cabi_post_local:wasm-tools/tools#metadata-show']);
     } catch(err) {
-      postReturn1Async = exports1['cabi_post_local:wasm-tools/tools#metadata-show'];
+      postReturn2Async = exports1['cabi_post_local:wasm-tools/tools#metadata-show'];
     }
     
     _initialized = true;
@@ -11910,6 +12203,7 @@ export const $init = (() => {
     toolsPrint = exports1['local:wasm-tools/tools#print'];
     toolsComponentNew = exports1['local:wasm-tools/tools#component-new'];
     toolsComponentWit = exports1['local:wasm-tools/tools#component-wit'];
+    toolsComponentWitMetadataForWorld = exports1['local:wasm-tools/tools#component-wit-metadata-for-world'];
     toolsComponentEmbed = exports1['local:wasm-tools/tools#component-embed'];
     toolsMetadataShow = exports1['local:wasm-tools/tools#metadata-show'];
     toolsMetadataAdd = exports1['local:wasm-tools/tools#metadata-add'];
@@ -11940,6 +12234,7 @@ const tools = {
   componentEmbed: componentEmbed,
   componentNew: componentNew,
   componentWit: componentWit,
+  componentWitMetadataForWorld: componentWitMetadataForWorld,
   metadataAdd: metadataAdd,
   metadataShow: metadataShow,
   parse: parse,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bytecodealliance/jco",
-    "version": "1.17.9-rc.0",
+    "version": "1.18.0",
     "description": "JavaScript tooling for working with WebAssembly Components",
     "keywords": [
         "Component",
@@ -73,8 +73,9 @@
         "prepack": "cargo xtask build release"
     },
     "dependencies": {
-        "@bytecodealliance/componentize-js": "^0.19.3",
-        "@bytecodealliance/preview2-shim": "^0.17.3",
+        "@bytecodealliance/componentize-js": "^0.20.0",
+        "@bytecodealliance/componentize-js-0-19-3": "npm:@bytecodealliance/componentize-js@^0.19.3",
+        "@bytecodealliance/preview2-shim": "^0.17.9",
         "binaryen": "^123.0.0",
         "commander": "^14",
         "mkdirp": "^3",

package/src/cmd/componentize.js

@@ -1,6 +1,9 @@
 import { stat, readFile, writeFile } from "node:fs/promises";
 import { resolve, basename } from "node:path";
-import { styleText } from "../common.js";
+
+import * as wasmToolsComponent from "../../obj/wasm-tools.js";
+
+import { styleText, isWindows } from "../common.js";
 
 /** All features that can be enabled/disabled */
 const ALL_FEATURES = ["clocks", "http", "random", "stdio", "fetch-event"];
@@ -8,19 +11,69 @@ const ALL_FEATURES = ["clocks", "http", "random", "stdio", "fetch-event"];
 /** Features that should be used for --debug mode */
 const DEBUG_FEATURES = ["stdio"];
 
-export async function componentize(jsSource, opts) {
-    const { componentize: componentizeFn } = await eval('import("@bytecodealliance/componentize-js")');
+/**
+ * Detect whether the WIT of a given component contains an older version of
+ * `wasi:http` which necessitates an older version of `componentize-js`
+ *
+ * @param {string} witPath
+ * @returns bool
+ */
+async function usesOlderWasiHTTP(witPath, worldName) {
+    await wasmToolsComponent.$init;
+
+    witPath = (isWindows ? "//?/" : "") + resolve(witPath);
+    const worldMetadata = wasmToolsComponent.tools.componentWitMetadataForWorld(
+        { tag: "path", val: witPath },
+        worldName ?? null,
+    );
+
+    // Check if the an old `wasi:http/incoming-handler` version is exported
+    const exportsOldIncomingHandler = worldMetadata.exports.some((iface) => {
+        return (
+            iface.namespace === "wasi" &&
+            iface.version !== null &&
+            iface.version.major === 0n &&
+            iface.version.minor < 3n &&
+            iface.version.patch < 10n
+        );
+    });
 
+    const importsOldFetch = worldMetadata.imports.some((iface) => {
+        return (
+            iface.namespace === "wasi" &&
+            iface.version !== null &&
+            iface.version.major === 0n &&
+            iface.version.minor < 3n &&
+            iface.version.patch < 10n
+        );
+    });
+
+    return exportsOldIncomingHandler || importsOldFetch;
+}
+export async function componentize(jsSource, opts) {
     const { disableFeatures, enableFeatures } = calculateFeatureSet(opts);
 
     const source = await readFile(jsSource, "utf8");
-
     const witPath = resolve(opts.wit);
     const sourceName = basename(jsSource);
 
+    // Load an older version of componentize-js if we detect an older version of WASI HTTP in use
+    // as the version that is usable is baked into the StarlingMonkey version provided by a given version
+    // of componentize-js
+    let componentizeJSModule;
+    const useOldComponentizeJS = await usesOlderWasiHTTP(witPath, opts.worldName);
+    if (useOldComponentizeJS) {
+        // NOTE: if we were to use a version of componentize-js 0.20.0 or newer here,
+        // the build would fail, as newer versions do not support wasi:http < 0.2.10
+        // for fetch.
+        componentizeJSModule = await eval('import("@bytecodealliance/componentize-js-0-19-3")');
+    } else {
+        componentizeJSModule = await eval('import("@bytecodealliance/componentize-js")');
+    }
+
     let component;
     try {
-        const result = await componentizeFn(source, {
+        const result = await componentizeJSModule.componentize(source, {
             enableAot: opts.aot,
             aotMinStackSizeBytes: opts.aotMinStackSizeBytes,
             wevalBin: opts.wevalBin,
@@ -41,7 +94,7 @@ export async function componentize(jsSource, opts) {
             },
         });
         if (result.debug) {
-            console.error(`${styleText("cyan", "DEBUG")} Debug output\n${JSON.stringify(debug, null, 2)}\n`);
+            console.error(`${styleText("cyan", "DEBUG")} Debug output\n${JSON.stringify(result.debug, null, 2)}\n`);
         }
 
         component = result.component;

package/src/jco.js

@@ -25,7 +25,7 @@ program
     )
     .usage("<command> [options]")
     .enablePositionalOptions()
-    .version("1.17.9-rc.0");
+    .version("1.18.0");
 
 function myParseInt(value) {
     return parseInt(value, 10);