Merge pull request #8 from andrewmd5/next

next

Author: andrewmd5

bridge/CMakeLists.txt

@@ -27,8 +27,8 @@ set(CMAKE_STRIP "${WASI_SDK_PATH}/bin/llvm-strip")
 
 # Set WASI sysroot and target
 set(CMAKE_SYSROOT "${WASI_SDK_PATH}/share/wasi-sysroot")
-set(CMAKE_C_COMPILER_TARGET "wasm32-wasi-threads")
-set(CMAKE_CXX_COMPILER_TARGET "wasm32-wasi-threads")
+set(CMAKE_C_COMPILER_TARGET "wasm32-wasi")
+set(CMAKE_CXX_COMPILER_TARGET "wasm32-wasi")
 
 set(CMAKE_TRY_COMPILE_TARGET_TYPE "STATIC_LIBRARY")
 set(CMAKE_C_COMPILER_WORKS "1")
@@ -90,7 +90,7 @@ option(DISABLE_NANBOX "Disable nanbox" OFF)
 option(ENABLE_CODECACHE "Enable code cache" OFF)
 option(CACHE_PROFILE "Enable cache profile" OFF)
 option(ENABLE_MEM "Enable memory detection" OFF)
-option(ENABLE_ATOMICS "Enable Atomics" ON)
+option(ENABLE_ATOMICS "Enable Atomics" OFF)
 option(FORCE_GC "Enable force gc" OFF)
 option(ENABLE_ASAN "Enable address sanitizer" OFF)
 option(ENABLE_BIGNUM "Enable bignum" OFF)
@@ -110,6 +110,7 @@ add_compile_options(
   -D_WASI_EMULATED_MMAN
   -D_WASI_EMULATED_SIGNAL
   -D_WASI_EMULATED_PROCESS_CLOCKS
+  -DWASI_STACK_SIZE=${WASM_STACK_SIZE}
 )
 
 # Simplify for WASI
@@ -122,7 +123,7 @@ set(CMAKE_COMMON_FLAGS
     "${OPTIMIZATION_FLAGS} -fPIC -ffunction-sections -fdata-sections \
     -fno-short-enums -fno-strict-aliasing -Wall -Wextra -Wno-unused-parameter \
     -Wno-unused-function -faddrsig -Wno-c99-designator -Wno-unknown-warning-option \
-    -Wno-sign-compare -Wno-unused-but-set-variable -pthread -matomics -msimd128 -mmultivalue -mmutable-globals -mtail-call -msign-ext -mbulk-memory -mnontrapping-fptoint -mextended-const")
+    -Wno-sign-compare -Wno-unused-but-set-variable -msimd128 -mmultivalue -mmutable-globals -mtail-call -msign-ext -mbulk-memory -mnontrapping-fptoint -mextended-const")
 
 if(ENABLE_ASAN)
   add_definitions(-DHAKO_SANITIZE_LEAK)
@@ -281,7 +282,7 @@ set_target_properties(quickjs PROPERTIES
 
 # Add WASI-specific link options to the QuickJS library
 target_link_options(quickjs PRIVATE
-  "-Wl,--allow-undefined -Wl,wasi-emulated-signal -Wl,wasi-emulated-process-clocks -Wl,--shared-memory")
+  "-Wl,--allow-undefined -Wl,wasi-emulated-signal -Wl,wasi-emulated-process-clocks")
 
 # Build the hako WASM module
 set(hako_source
@@ -311,7 +312,6 @@ target_include_directories(hako_reactor PRIVATE
 # WASM-specific link options
 target_link_options(hako_reactor PRIVATE
     -mexec-model=reactor
-    -Wl,--import-memory,--export-memory
     -Wl,--no-entry
     -Wl,--export=malloc
     -Wl,--export=free

bridge/hako.c

@@ -1586,12 +1586,14 @@ HAKO_TypedArrayType WASM_EXPORT(HAKO_GetTypedArrayType)(LEPUSContext *ctx,
     return HAKO_TYPED_UINT32_ARRAY;
   case LEPUS_TYPED_INT32_ARRAY:
     return HAKO_TYPED_INT32_ARRAY;
+   case LEPUS_TYPED_FLOAT16_ARRAY:
+    return HAKO_TYPED_FLOAT16_ARRAY;
   case LEPUS_TYPED_FLOAT32_ARRAY:
     return HAKO_TYPED_FLOAT32_ARRAY;
   case LEPUS_TYPED_FLOAT64_ARRAY:
     return HAKO_TYPED_FLOAT64_ARRAY;
   default:
-    return HAKO_TYPED_UNKNOWN;
+    return -1;
   }
 }
 

bridge/hako.h

@@ -48,16 +48,18 @@ extern "C"
 
     typedef enum
     {
-        HAKO_TYPED_UNKNOWN = 0,
         HAKO_TYPED_UINT8_ARRAY = 1,
         HAKO_TYPED_UINT8C_ARRAY = 2,
         HAKO_TYPED_INT8_ARRAY = 3,
         HAKO_TYPED_UINT16_ARRAY = 4,
         HAKO_TYPED_INT16_ARRAY = 5,
         HAKO_TYPED_UINT32_ARRAY = 6,
         HAKO_TYPED_INT32_ARRAY = 7,
-        HAKO_TYPED_FLOAT32_ARRAY = 8,
-        HAKO_TYPED_FLOAT64_ARRAY = 9
+        HAKO_TYPED_BIG_INT64_ARRAY = 8,
+        HAKO_TYPED_BIG_UINT64_ARRAY = 9,
+        HAKO_TYPED_FLOAT16_ARRAY = 10,
+        HAKO_TYPED_FLOAT32_ARRAY = 11,
+        HAKO_TYPED_FLOAT64_ARRAY = 12
     } HAKO_TypedArrayType;
 
     typedef enum IsEqualOp

embedders/ts/src/etc/ffi.ts

@@ -1,8 +1,8 @@
 /**
- * Generated on: 2025-04-14 08:27:22
+ * Generated on: 2025-06-24 17:01:53
  * Source file: hako.h
- * Git commit: 1ac71aadb54d23306f1bee8b1b982128dfc4cf4f
- * Git branch: main
+ * Git commit: 7a9d6e411817d8012facedac0694be2cee4cb846
+ * Git branch: next
  * Git author: andrew <1297077+andrewmd5@users.noreply.github.com>
  * Git remote: https://github.com/andrewmd5/hako.git
  */

embedders/ts/src/etc/types.ts

@@ -585,17 +585,14 @@ export function evalOptionsToFlags(
 /**
  * JavaScript Promise states.
  */
-export enum PromiseState {
+export type PromiseState =
   /** Promise has not been resolved or rejected yet */
-  Pending = 0,
-
+  | "pending"
   /** Promise has been resolved with a value */
-  Fulfilled = 1,
-
+  | "fulfilled"
   /** Promise has been rejected with a reason */
-  Rejected = 2,
-}
-
+  | "rejected";
+  
 //=============================================================================
 // Equality Operations
 //=============================================================================
@@ -1031,5 +1028,8 @@ export type TypedArrayType =
   | "Int16Array"
   | "Uint32Array"
   | "Int32Array"
+  | "BigUint64Array"
+  | "BigInt64Array"
+  | "Float16Array"
   | "Float32Array"
   | "Float64Array";

embedders/ts/src/index.ts

@@ -91,8 +91,6 @@ export interface HakoOptions<TOptions, TResponse> {
       initial?: number;
       /** Maximum memory size in bytes */
       maximum?: number;
-      /** Whether to use shared memory */
-      shared?: boolean;
       /** Bring Your Own Memory - use an existing WebAssembly memory instance */
       byom?: WebAssembly.Memory;
     };
@@ -129,7 +127,7 @@ export async function createHakoRuntime<TOptions, TResponse>(
   const memConfig = options.wasm?.memory || {};
   const initialMemory = memConfig.initial || defaultInitialMemory;
   const maximumMemory = memConfig.maximum || defaultMaximumMemory;
-  const sharedMemory = memConfig.shared !== undefined ? memConfig.shared : true;
+
 
   // Use BYOM (Bring Your Own Memory) or create a new one
   let wasmMemory: WebAssembly.Memory;
@@ -142,7 +140,7 @@ export async function createHakoRuntime<TOptions, TResponse>(
     wasmMemory = new WebAssembly.Memory({
       initial: initialPages,
       maximum: maximumPages,
-      shared: sharedMemory,
+      shared: false,
     });
   }
 

embedders/ts/src/vm/context.ts

@@ -368,17 +368,43 @@ export class VMContext implements Disposable {
         `Expected a Promise-like value, received ${promiseLikeHandle.type}`
       );
     }
+
     using vmResolveResult = Scope.withScope((scope) => {
       const global = this.getGlobalObject();
       const vmPromise = scope.manage(global.getProperty("Promise"));
       // biome-ignore lint/style/noNonNullAssertion: <explanation>
       const vmPromiseResolve = scope.manage(vmPromise?.getProperty("resolve"))!;
       return this.callFunction(vmPromiseResolve, vmPromise, promiseLikeHandle);
     });
+
     if (vmResolveResult.error) {
       return Promise.resolve(vmResolveResult);
     }
 
+    const resolvedPromise = vmResolveResult.value;
+
+    // Check if the promise is already settled
+    const state = resolvedPromise.getPromiseState();
+
+    if (state === "fulfilled") {
+      const result = resolvedPromise.getPromiseResult();
+      if (result) {
+        return Promise.resolve(this.success(result));
+      }
+        // This shouldn't happen for fulfilled promises, but handle gracefully
+        return Promise.resolve(this.success(this.newValue(undefined)));
+    }
+
+    if (state === "rejected") {
+      const error = resolvedPromise.getPromiseResult();
+      if (error) {
+        return Promise.resolve(this.fail(error));
+      }
+        // This shouldn't happen for rejected promises, but handle gracefully
+        return Promise.resolve(this.fail(this.newValue(undefined)));
+    }
+
+    // Promise is pending, set up async handlers
     return new Promise<VMContextResult<VMValue>>((resolve) => {
       Scope.withScope((scope) => {
         const resolveHandle = scope.manage(
@@ -393,7 +419,7 @@ export class VMContext implements Disposable {
           })
         );
 
-        const promiseHandle = scope.manage(vmResolveResult.value);
+        const promiseHandle = scope.manage(resolvedPromise);
         // biome-ignore lint/style/noNonNullAssertion: <explanation>
         const promiseThenHandle = scope.manage(
           promiseHandle.getProperty("then")

embedders/ts/src/vm/value.ts

@@ -6,7 +6,7 @@ import {
   type PropertyDescriptor,
   PropertyEnumFlags,
   EqualOp,
-  PromiseState,
+  type PromiseState,
   IsEqualOp,
   LEPUS_BOOLToBoolean,
   type JSType,
@@ -358,9 +358,15 @@ export class VMValue implements Disposable {
         return "Uint32Array";
       case 7:
         return "Int32Array";
-      case 8:
-        return "Float32Array";
+        case 8:
+         return "BigInt64Array";
       case 9:
+        return "BigUint64Array";
+      case 10:
+        return "Float16Array";
+      case 11:
+        return "Float32Array";
+      case 12:
         return "Float64Array";
       default:
         return "Unknown";
@@ -769,15 +775,25 @@ export class VMValue implements Disposable {
    * @throws Error if the value is not a promise
    * @throws {PrimJSUseAfterFree} If the value has been disposed
    */
-  getPromiseState(): PromiseState | null {
+  getPromiseState(): PromiseState | undefined {
     this.assertAlive();
     if (!this.isPromise()) {
       throw new Error("Value is not a promise");
     }
-    return this.context.container.exports.HAKO_PromiseState(
+    switch (this.context.container.exports.HAKO_PromiseState(
       this.context.pointer,
       this.handle
-    );
+    )) {
+      case 0:
+        return "pending";
+      case 1:
+        return "fulfilled";
+      case 2:
+        return "rejected";
+      default:
+        return undefined;
+
+    }
   }
 
   /**
@@ -794,7 +810,7 @@ export class VMValue implements Disposable {
     }
 
     const state = this.getPromiseState();
-    if (state !== PromiseState.Fulfilled && state !== PromiseState.Rejected) {
+    if (state !== "fulfilled" && state !== "rejected") {
       return undefined;
     }
 

embedders/ts/tests/context.test.ts

@@ -601,6 +601,42 @@ fibonacci(100);
   });
 
   describe("Promise handling", () => {
+
+    it("should resolve already-settled async function promises without deadlocking", async () => {
+      // This test reproduces the deadlock issue from the GitHub issue
+      const code = `export const run = async (name) => { return "Hello" + name };`;
+
+      using result = context.evalCode(code, { type: "module" });
+      expect(result.error).toBeUndefined();
+
+      using mod = result.unwrap();
+      using runFunction = mod.getProperty("run");
+
+      // Call the async function - this creates an already-settled promise
+      using arg = context.newValue("Test");
+      console.log("Calling runFunction with arg:", arg.asString());
+      using callResult = context.callFunction(runFunction, null, arg);
+      using promiseHandle = callResult.unwrap();
+      console.log("Promise handle created:");
+
+      // Verify it's a promise and already settled
+      expect(promiseHandle.isPromise()).toBe(true);
+     
+
+      // Before the fix: this would deadlock because the promise is already settled
+      // After the fix: this should resolve without blocking
+      const startTime = Date.now();
+      console.log("Resolving promise handle...");
+      using resolvedResult = await context.resolvePromise(promiseHandle);
+      const endTime = Date.now();
+
+      // Should resolve quickly (within reasonable time, not hang indefinitely)
+      expect(endTime - startTime).toBeLessThan(1000); // Should be much faster than 1 second
+
+      using resolvedHandle = resolvedResult.unwrap();
+      expect(resolvedHandle.asString()).toBe("HelloTest");
+    });
+
     it("should handle promise resolution", async () => {
       const fakeFileSystem = new Map([["example.txt", "Example file content"]]);
       using readFileHandle = context.newFunction("readFile", (pathHandle) => {