DRAFT: Adding JSPI and Asyncify

crates/js-component-bindgen-component/src/lib.rs

@@ -42,6 +42,19 @@ impl From<InstantiationMode> for js_component_bindgen::InstantiationMode {
     }
 }
 
+impl From<StaticWasmSourceImportsMode> for js_component_bindgen::StaticWasmSourceImportsMode {
+    fn from(value: StaticWasmSourceImportsMode) -> Self {
+        match value {
+            StaticWasmSourceImportsMode::ProposedStandardImportSource => {
+                js_component_bindgen::StaticWasmSourceImportsMode::ProposedStandardImportSource
+            }
+            StaticWasmSourceImportsMode::NonStandardImport => {
+                js_component_bindgen::StaticWasmSourceImportsMode::NonStandardImport
+            }
+        }
+    }
+}
+
 impl From<BindingsMode> for js_component_bindgen::BindingsMode {
     fn from(value: BindingsMode) -> Self {
         match value {
@@ -53,6 +66,20 @@ impl From<BindingsMode> for js_component_bindgen::BindingsMode {
     }
 }
 
+impl From<AsyncMode> for js_component_bindgen::AsyncMode {
+    fn from(value: AsyncMode) -> Self {
+        match value {
+            AsyncMode::Sync => js_component_bindgen::AsyncMode::Sync,
+            AsyncMode::Jspi(AsyncImportsExports { imports, exports }) => {
+                js_component_bindgen::AsyncMode::JavaScriptPromiseIntegration { imports, exports }
+            }
+            AsyncMode::Asyncify(AsyncImportsExports { imports, exports }) => {
+                js_component_bindgen::AsyncMode::Asyncify { imports, exports }
+            }
+        }
+    }
+}
+
 struct JsComponentBindgenComponent;
 
 export!(JsComponentBindgenComponent);
@@ -64,6 +91,9 @@ impl Guest for JsComponentBindgenComponent {
             name: options.name,
             no_typescript: options.no_typescript.unwrap_or(false),
             instantiation: options.instantiation.map(Into::into),
+            cache_wasm_compile: options.cache_wasm_compile.unwrap_or(false),
+            static_wasm_source_imports: options.static_wasm_source_imports.map(Into::into),
+            esm_imports: options.esm_imports.unwrap_or(false),
             map: options.map.map(|map| map.into_iter().collect()),
             no_nodejs_compat: options.no_nodejs_compat.unwrap_or(false),
             base64_cutoff: options.base64_cutoff.unwrap_or(5000) as usize,
@@ -75,6 +105,7 @@ impl Guest for JsComponentBindgenComponent {
             no_namespaced_exports: options.no_namespaced_exports.unwrap_or(false),
             multi_memory: options.multi_memory.unwrap_or(false),
             import_bindings: options.import_bindings.map(Into::into),
+            async_mode: options.async_mode.map(Into::into),
         };
 
         let js_component_bindgen::Transpiled {
@@ -152,6 +183,9 @@ impl Guest for JsComponentBindgenComponent {
             no_typescript: false,
             no_nodejs_compat: false,
             instantiation: opts.instantiation.map(Into::into),
+            cache_wasm_compile: false,
+            static_wasm_source_imports: None,
+            esm_imports: opts.esm_imports.unwrap_or(false),
             map: opts.map.map(|map| map.into_iter().collect()),
             tla_compat: opts.tla_compat.unwrap_or(false),
             valid_lifting_optimization: false,
@@ -160,6 +194,7 @@ impl Guest for JsComponentBindgenComponent {
             no_namespaced_exports: false,
             multi_memory: false,
             import_bindings: None,
+            async_mode: opts.async_mode.map(Into::into),
         };
 
         let files = generate_types(name, resolve, world, opts).map_err(|e| e.to_string())?;

crates/js-component-bindgen-component/wit/js-component-bindgen.wit

@@ -9,6 +9,11 @@ world js-component-bindgen {
     sync,
   }
 
+  variant static-wasm-source-imports-mode {
+    proposed-standard-import-source,
+    non-standard-import,
+  }
+
   variant bindings-mode {
     js,
     hybrid,
@@ -28,6 +33,18 @@ world js-component-bindgen {
     /// of the direct importable native ESM output.
     instantiation: option<instantiation-mode>,
 
+    /// If `instantiation` is set, on the first `instantiate` call the compiled
+    /// Wasm modules are cached for subsequent `instantiate` calls.
+    cache-wasm-compile: option<bool>,
+
+    /// Static import of Wasm module with the proposed standard source phase
+    /// imports or use the non-standard import syntax.
+    static-wasm-source-imports: option<static-wasm-source-imports-mode>,
+
+    /// If `instantiation` is set, instead of providing an import object, use
+    /// ESM imports.
+    esm-imports: option<bool>,
+
     /// Import bindings generation mode
     import-bindings: option<bindings-mode>,
 
@@ -62,6 +79,24 @@ world js-component-bindgen {
     /// Whether to output core Wasm utilizing multi-memory or to polyfill
     /// this handling.
     multi-memory: option<bool>,
+
+    /// Configure whether to use `async` imports or exports with
+    /// JavaScript Promise Integration (JSPI) or Asyncify.
+    async-mode: option<async-mode>,
+  }
+
+  record async-imports-exports {
+    imports: list<string>,
+    exports: list<string>,
+  }
+
+  variant async-mode {
+    /// default to sync mode
+    sync,
+    /// use JavaScript Promise Integration (JSPI)
+    jspi(async-imports-exports),
+    /// use Asyncify
+    asyncify(async-imports-exports),
   }
 
   variant wit {
@@ -88,9 +123,15 @@ world js-component-bindgen {
     %world: option<string>,
     tla-compat: option<bool>,
     instantiation: option<instantiation-mode>,
+    /// If `instantiation` is set, instead of providing an import object, use
+    /// ESM imports.
+    esm-imports: option<bool>,
     map: option<maps>,
     /// Features that should be enabled as part of feature gating
     features: option<enabled-feature-set>,
+    /// Configure whether to use `async` imports or exports with
+    /// JavaScript Promise Integration (JSPI) or Asyncify.
+    async-mode: option<async-mode>,
   }
 
   enum export-type {

crates/js-component-bindgen/src/function_bindgen.rs

@@ -86,6 +86,7 @@ pub struct FunctionBindgen<'a> {
     pub callee: &'a str,
     pub callee_resource_dynamic: bool,
     pub resolve: &'a Resolve,
+    pub is_async: bool,
 }
 
 impl FunctionBindgen<'_> {
@@ -1048,7 +1049,13 @@ impl Bindgen for FunctionBindgen<'_> {
             Instruction::CallWasm { sig, .. } => {
                 let sig_results_length = sig.results.len();
                 self.bind_results(sig_results_length, results);
-                uwriteln!(self.src, "{}({});", self.callee, operands.join(", "));
+                let maybe_async_await = if self.is_async { "await " } else { "" };
+                uwriteln!(
+                    self.src,
+                    "{maybe_async_await}{}({});",
+                    self.callee,
+                    operands.join(", ")
+                );
 
                 if let Some(prefix) = self.tracing_prefix {
                     let to_result_string = self.intrinsic(Intrinsic::ToResultString);
@@ -1066,15 +1073,20 @@ impl Bindgen for FunctionBindgen<'_> {
 
             Instruction::CallInterface { func } => {
                 let results_length = func.results.len();
+                let maybe_async_await = if self.is_async { "await " } else { "" };
                 let call = if self.callee_resource_dynamic {
                     format!(
-                        "{}.{}({})",
+                        "{maybe_async_await}{}.{}({})",
                         operands[0],
                         self.callee,
                         operands[1..].join(", ")
                     )
                 } else {
-                    format!("{}({})", self.callee, operands.join(", "))
+                    format!(
+                        "{maybe_async_await}{}({})",
+                        self.callee,
+                        operands.join(", ")
+                    )
                 };
                 if self.err == ErrHandling::ResultCatchHandler {
                     // result<_, string> allows JS error coercion only, while