fix(bindgen): fix WASM3/GC transpilation and P3 async stream runtime bugs

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

@@ -98,7 +98,7 @@ impl<'a> Translation<'a> {
         }
 
         // Set up wasm features to use
-        let mut features = WasmFeatures::default();
+        let mut features = WasmFeatures::WASM3 | WasmFeatures::WIDE_ARITHMETIC;
         features.set(WasmFeatures::MULTI_MEMORY, false);
 
         match Validator::new_with_features(features).validate_all(translation.wasm) {

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

@@ -1491,11 +1491,24 @@ impl Bindgen for FunctionBindgen<'_> {
                               taskID: task.id(),
                               componentIdx: task.componentIdx(),
                               fn: () => {callee}({args}),
-                          }});
-                          "#,
+                          }});"#,
                     callee = self.callee,
                     args = operands.join(", "),
                 );
+                // For async exports using task.return, the JSPI Promising wrapper
+                // returns undefined (void core wasm function). The task's completion
+                // promise (resolved by task.return) provides the already-lifted result.
+                if self.is_async && sig_results_length > 0 {
+                    uwriteln!(
+                        self.src,
+                        r#"
+                          if (ret === undefined) {{
+                              const taskResult = await task.completionPromise();
+                              if (taskResult !== undefined) {{ return taskResult; }}
+                          }}
+                          "#,
+                    );
+                }
 
                 if self.tracing_enabled {
                     let prefix = self.tracing_prefix;

crates/js-component-bindgen/src/intrinsics/lower.rs

@@ -542,15 +542,18 @@ impl LowerIntrinsic {
 
                             ctx.resultPtr = originalPtr + payloadOffset32;
 
-                            const payloadBytesWritten = lowerFn({{
-                                memory,
-                                realloc,
-                                vals: [val],
-                                storagePtr,
-                                storageLen,
-                                componentIdx,
-                            }});
-                            let bytesWritten = payloadOffset + payloadBytesWritten;
+                            let payloadBytesWritten = 0;
+                            if (lowerFn) {{
+                                payloadBytesWritten = lowerFn({{
+                                    memory,
+                                    realloc,
+                                    vals: [val],
+                                    storagePtr,
+                                    storageLen,
+                                    componentIdx,
+                                }});
+                            }}
+                            let bytesWritten = payloadOffset32 + payloadBytesWritten;
 
                             const rem = ctx.storagePtr % align32;
                             if (rem !== 0) {{

crates/js-component-bindgen/src/intrinsics/mod.rs

@@ -1213,6 +1213,9 @@ pub fn render_intrinsics(args: RenderIntrinsicsArgs) -> Source {
     if args
         .intrinsics
         .contains(&Intrinsic::Waitable(WaitableIntrinsic::WaitableSetPoll))
+        || args
+            .intrinsics
+            .contains(&Intrinsic::Waitable(WaitableIntrinsic::WaitableSetWait))
     {
         args.intrinsics
             .extend([&Intrinsic::Host(HostIntrinsic::StoreEventInComponentMemory)]);
@@ -1268,6 +1271,22 @@ pub fn render_intrinsics(args: RenderIntrinsicsArgs) -> Source {
         ]);
     }
 
+    if args
+        .intrinsics
+        .contains(&Intrinsic::Lower(LowerIntrinsic::LowerFlatResult))
+    {
+        args.intrinsics
+            .insert(Intrinsic::Lower(LowerIntrinsic::LowerFlatVariant));
+    }
+
+    if args
+        .intrinsics
+        .contains(&Intrinsic::Lower(LowerIntrinsic::LowerFlatOption))
+    {
+        args.intrinsics
+            .insert(Intrinsic::Lower(LowerIntrinsic::LowerFlatVariant));
+    }
+
     if args
         .intrinsics
         .contains(&Intrinsic::Lower(LowerIntrinsic::LowerFlatVariant))
@@ -1364,10 +1383,14 @@ pub fn render_intrinsics(args: RenderIntrinsicsArgs) -> Source {
     if args
         .intrinsics
         .contains(&Intrinsic::AsyncStream(AsyncStreamIntrinsic::StreamWrite))
+        || args
+            .intrinsics
+            .contains(&Intrinsic::AsyncStream(AsyncStreamIntrinsic::StreamRead))
     {
         args.intrinsics.extend([
             &Intrinsic::GlobalBufferManager,
             &Intrinsic::AsyncTask(AsyncTaskIntrinsic::AsyncBlockedConstant),
+            &Intrinsic::AsyncEventCodeEnum,
         ]);
     }
 

crates/js-component-bindgen/src/intrinsics/p3/async_stream.rs

@@ -1140,7 +1140,7 @@ impl AsyncStreamIntrinsic {
                     r#"
                     class {host_stream_class_name} {{
                         #componentIdx;
-                        #streamEndIdx;
+                        #streamEndWaitableIdx;
                         #streamTableIdx;
 
                         #payloadLiftFn;
@@ -1162,24 +1162,28 @@ impl AsyncStreamIntrinsic {
                             if (!args.payloadLowerFn) {{ throw new TypeError("missing payload lower fn"); }}
                             this.#payloadLowerFn = args.payloadLowerFn;
 
-                            if (args.streamEndIdx === undefined) {{ throw new Error("missing stream idx"); }}
+                            if (args.streamEndWaitableIdx === undefined) {{ throw new Error("missing stream idx"); }}
                             if (args.streamTableIdx === undefined) {{ throw new Error("missing stream table idx"); }}
-                            this.#streamEndIdx = args.streamEndIdx;
+                            this.#streamEndWaitableIdx = args.streamEndWaitableIdx;
                             this.#streamTableIdx = args.streamTableIdx;
 
                             this.#isUnitStream = args.isUnitStream;
                         }}
 
+                        setRep(rep) {{
+                            this.#rep = rep;
+                        }}
+
                         createUserStream(args) {{
                            if (this.#userStream) {{ return this.#userStream; }}
                            if (this.#rep === null) {{ throw new Error("unexpectedly missing rep for host stream"); }}
 
                            const cstate = {get_or_create_async_state_fn}(this.#componentIdx);
                            if (!cstate) {{ throw new Error(`missing async state for component [${{this.#componentIdx}}]`); }}
 
-                           const streamEnd = cstate.getStreamEnd({{ tableIdx: this.#streamTableIdx, streamEndIdx: this.#streamEndIdx }});
+                           const streamEnd = cstate.getStreamEnd({{ tableIdx: this.#streamTableIdx, streamEndWaitableIdx: this.#streamEndWaitableIdx }});
                            if (!streamEnd) {{
-                               throw new Error(`missing stream [${{this.#streamEndIdx}}] (table [${{this.#streamTableIdx}}], component [${{this.#componentIdx}}]`);
+                               throw new Error(`missing stream [${{this.#streamEndWaitableIdx}}] (table [${{this.#streamTableIdx}}], component [${{this.#componentIdx}}]`);
                            }}
 
                             return new {external_stream_class}({{
@@ -1266,6 +1270,20 @@ impl AsyncStreamIntrinsic {
                             this.#writeFn(obj);
                         }}
 
+                        intoReadableStream() {{
+                            const stream = this;
+                            return new ReadableStream({{
+                                async pull(controller) {{
+                                    const chunk = await stream.next();
+                                    if (chunk === undefined) {{
+                                        controller.close();
+                                    }} else {{
+                                        controller.enqueue(chunk);
+                                    }}
+                                }},
+                            }});
+                        }}
+
                         [{symbol_dispose}]() {{
                             this.#dropFn();
                         }}
@@ -1366,7 +1384,7 @@ impl AsyncStreamIntrinsic {
                         {debug_log_fn}('[{stream_new_from_lift_fn}()] args', {{ ctx }});
                         const {{
                             componentIdx,
-                            streamEndIdx,
+                            streamEndWaitableIdx,
                             streamTableIdx,
                             payloadLiftFn,
                             payloadTypeSize32,
@@ -1376,7 +1394,7 @@ impl AsyncStreamIntrinsic {
 
                         const stream = new {host_stream_class}({{
                             componentIdx,
-                            streamEndIdx,
+                            streamEndWaitableIdx,
                             streamTableIdx,
                             payloadLiftFn: payloadLiftFn,
                             payloadLowerFn: payloadLowerFn,
@@ -1457,9 +1475,23 @@ impl AsyncStreamIntrinsic {
                             throw new Error(`stream end table idx [${{streamEnd.streamTableIdx()}}] != operation table idx [${{streamTableIdx}}]`);
                         }}
 
+                        const memory = getMemoryFn();
+
+                        // Host stream write hook: if a global hook is registered, deliver
+                        // stream data directly from linear memory, bypassing the rendezvous.
+                        // This enables WASI shims to receive bulk data from stream.write.
+                        if (typeof globalThis._jcoStreamWriteHook === 'function' && streamEnd.isWritable()) {{
+                            const actualCount = count >>> 0;
+                            const data = new Uint8Array(memory.buffer, ptr, actualCount);
+                            const handled = globalThis._jcoStreamWriteHook(streamEndWaitableIdx, new Uint8Array(data));
+                            if (handled) {{
+                                return (actualCount << 4) | 0;
+                            }}
+                        }}
+
                         const result = await streamEnd.copy({{
                             isAsync,
-                            memory: getMemoryFn(),
+                            memory,
                             ptr,
                             count,
                             eventCode: {event_code},

crates/js-component-bindgen/src/intrinsics/p3/waitable.rs

@@ -392,8 +392,9 @@ impl WaitableIntrinsic {
                             throw Error(`task component [${{task.componentIdx}}] !== executing component [${{componentIdx}}]`);
                         }}
 
-                        const event = await task.waitForEvent({{ waitableSetRep, isAsync }});
-                        return {store_event_in_component_memory_fn}(memory, task, event, resultPtr);
+                        const memory = getMemoryFn();
+                        const event = await task.waitUntil({{ waitableSetRep, readyFn: () => true, cancellable: false }});
+                        return {store_event_in_component_memory_fn}({{ memory, ptr: resultPtr, event }});
                     }}
                 "#));
             }

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

@@ -128,17 +128,14 @@ pub fn transpile(component: &[u8], opts: TranspileOpts) -> Result<Transpiled> {
     // This does not require the correct execution of the related features post-transpilation,
     // but without the right features specified, components won't load at all.
     let mut validator = wasmtime_environ::wasmparser::Validator::new_with_features(
-        WasmFeatures::WASM2
+        WasmFeatures::WASM3
             | WasmFeatures::COMPONENT_MODEL
             | WasmFeatures::CM_ASYNC
             | WasmFeatures::CM_ASYNC_BUILTINS
             | WasmFeatures::CM_ASYNC_STACKFUL
             | WasmFeatures::CM_ERROR_CONTEXT
             | WasmFeatures::CM_FIXED_SIZE_LIST
-            | WasmFeatures::EXCEPTIONS
-            | WasmFeatures::EXTENDED_CONST
-            | WasmFeatures::MEMORY64
-            | WasmFeatures::MULTI_MEMORY,
+            | WasmFeatures::WIDE_ARITHMETIC,
     );
 
     let mut types = ComponentTypesBuilder::new(&validator);

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

@@ -1202,12 +1202,12 @@ impl<'a> Instantiator<'a, '_> {
                 uwriteln!(
                     self.src.js,
                     r#"
-                    const trampoline{i} = {waitable_set_wait_fn}.bind(null, {{
+                    const trampoline{i} = new WebAssembly.Suspending({waitable_set_wait_fn}.bind(null, {{
                         componentIdx: {instance_idx},
                         isAsync: {async_},
                         memoryIdx: {memory_idx},
                         getMemoryFn: () => memory{memory_idx},
-                    }});
+                    }}));
                     "#,
                 );
             }

packages/jco/test/p3/async.js

@@ -1,11 +1,11 @@
 import { join } from "node:path";
 
-import { suite, test, assert, expect } from "vitest";
+import { suite, test, assert, expect, afterEach } from "vitest";
 
 import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation";
 
 import { setupAsyncTest } from "../helpers.js";
-import { AsyncFunction, LOCAL_TEST_COMPONENTS_DIR } from "../common.js";
+import { AsyncFunction, LOCAL_TEST_COMPONENTS_DIR, P3_COMPONENT_FIXTURES_DIR } from "../common.js";
 
 suite("Async (WASI P3)", () => {
     // see: https://github.com/bytecodealliance/jco/issues/1076
@@ -88,4 +88,37 @@ suite("Async (WASI P3)", () => {
 
         await cleanup();
     });
+
+    test("GC + WASI P3 hello world via stream write hook", async () => {
+        const chunks = [];
+        const origHook = globalThis._jcoStreamWriteHook;
+        globalThis._jcoStreamWriteHook = (_writableEndIdx, data) => {
+            chunks.push(new TextDecoder().decode(data));
+            return true;
+        };
+
+        try {
+            const { instance, cleanup } = await setupAsyncTest({
+                component: {
+                    path: join(P3_COMPONENT_FIXTURES_DIR, "gc/hello-gc-p3.wasm"),
+                    imports: {
+                        "wasi:cli/stdout": {
+                            writeViaStream: () => ({ tag: "ok" }),
+                        },
+                    },
+                },
+            });
+
+            await instance.run();
+            assert.strictEqual(chunks.join(""), "Hello, world!\n");
+
+            await cleanup();
+        } finally {
+            if (origHook) {
+                globalThis._jcoStreamWriteHook = origHook;
+            } else {
+                delete globalThis._jcoStreamWriteHook;
+            }
+        }
+    });
 });

packages/jco/test/p3/transpile.js

@@ -97,6 +97,8 @@ const P3_FIXTURE_COMPONENTS = [
     "error-context/async-error-context.wasm",
     "error-context/async-error-context-callee.wasm",
     "error-context/async-error-context-caller.wasm",
+
+    "gc/hello-gc-p3.wasm",
 ];
 
 suite("Transpile (WASI P3)", () => {