emnapi 1.4.5 → 1.6.0

package/CMakeLists.txt

@@ -44,6 +44,7 @@ set(ENAPI_BASIC_SRC
   "${CMAKE_CURRENT_SOURCE_DIR}/src/node_api.c"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/async_cleanup_hook.c"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/async_context.c"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/wasi_wait.c"
 )
 set(EMNAPI_THREADS_SRC
   "${CMAKE_CURRENT_SOURCE_DIR}/src/async_work.c"
@@ -70,6 +71,10 @@ set(EMNAPI_BASIC_TARGET_NAME "emnapi-basic")
 set(EMNAPI_BASIC_MT_TARGET_NAME "emnapi-basic-mt")
 set(EMNAPI_TARGET_NAME "emnapi")
 set(EMNAPI_MT_TARGET_NAME "emnapi-mt")
+
+set(EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME "emnapi-basic-napi-rs-mt")
+set(EMNAPI_NAPI_RS_MT_TARGET_NAME "emnapi-napi-rs-mt")
+
 set(DLMALLOC_TARGET_NAME "dlmalloc")
 set(DLMALLOC_MT_TARGET_NAME "dlmalloc-mt")
 set(EMMALLOC_TARGET_NAME "emmalloc")
@@ -155,6 +160,31 @@ else()
   set(EMNAPI_BUILD_BASIC_MT OFF)
 endif()
 
+if(IS_WASM32_WASIP1_THREADS)
+  set(EMNAPI_BUILD_FOR_NAPI_RS ON)
+else()
+  set(EMNAPI_BUILD_FOR_NAPI_RS OFF)
+endif()
+
+if(EMNAPI_BUILD_FOR_NAPI_RS)
+  add_library(${EMNAPI_NAPI_RS_MT_TARGET_NAME} STATIC ${EMNAPI_SRC} ${UV_SRC})
+  target_include_directories(${EMNAPI_NAPI_RS_MT_TARGET_NAME} PUBLIC ${EMNAPI_INCLUDE})
+  target_compile_definitions(${EMNAPI_NAPI_RS_MT_TARGET_NAME}
+    PUBLIC ${EMNAPI_DEFINES} "NAPI_EXTERN=__attribute__((__import_module__(\"env\")))"
+  )
+
+  add_library(${EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME} STATIC
+    ${ENAPI_BASIC_SRC}
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/thread/async_worker_create.c"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/thread/async_worker_init.S"
+  )
+  target_include_directories(${EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME} PUBLIC ${EMNAPI_INCLUDE})
+  target_compile_definitions(${EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME}
+    PUBLIC ${EMNAPI_DEFINES} "NAPI_EXTERN=__attribute__((__import_module__(\"env\")))"
+    PRIVATE "EMNAPI_DISABLE_UV"
+  )
+endif()
+
 if(EMNAPI_BUILD_BASIC_MT)
   add_library(${EMNAPI_BASIC_MT_TARGET_NAME} STATIC
     ${ENAPI_BASIC_SRC}
@@ -222,6 +252,10 @@ if(LIB_ARCH)
   if(EMNAPI_BUILD_BASIC_MT)
     install(TARGETS ${EMNAPI_BASIC_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
   endif()
+  if(EMNAPI_BUILD_FOR_NAPI_RS)
+    install(TARGETS ${EMNAPI_NAPI_RS_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
+    install(TARGETS ${EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
+  endif()
   if(IS_WASM32)
     install(TARGETS ${DLMALLOC_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
     install(TARGETS ${DLMALLOC_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")

package/README.md

@@ -816,8 +816,9 @@ Now emnapi has 3 implementations of async work and 2 implementations of TSFN:
 There are some limitations on browser about wasi-libc's pthread implementation, for example
 `pthread_mutex_lock` may call `__builtin_wasm_memory_atomic_wait32`(`memory.atomic.wait32`)
 which is disallowed in browser JS main thread. While Emscripten's pthread implementation
-has considered usage in browser. If you need to run your addon with multithreaded features on browser,
-we recommend you use Emscripten A & D, or bare wasm32 C & E.
+has considered usage in browser. This issue can be solved by upgrading `wasi-sdk` to v26+
+and emnapi v1.5.0+ then pass `--export=emnapi_thread_crashed` to the linker. If you need to
+run your addon with multithreaded features, we recommend you use A & D or C & E.
 
 Note: For browsers, all the multithreaded features relying on Web Workers (Emscripten pthread also relying on Web Workers)
 require cross-origin isolation to enable `SharedArrayBuffer`. You can make a page cross-origin isolated
@@ -879,6 +880,7 @@ elseif(CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi-threads")
     "-Wl,--export-if-defined=node_api_module_get_api_version_v1"
     "-Wl,--export=malloc"
     "-Wl,--export=free"
+    "-Wl,--export=emnapi_thread_crashed"
     "-Wl,--import-undefined"
     "-Wl,--export-table"
   )

package/common.gypi

@@ -308,6 +308,7 @@
               'src/async_cleanup_hook.c',
               'src/async_context.c',
               'src/async_work.c',
+              'src/wasi_wait.c',
               'src/threadsafe_function.c',
               'src/uv/uv-common.c',
               'src/uv/threadpool.c',
@@ -370,6 +371,16 @@
                       ]
                     },
                   }],
+                  ['OS == "wasi"', {
+                    'ldflags': [
+                      '-Wl,--export=emnapi_thread_crashed',
+                    ],
+                    'xcode_settings': {
+                      'OTHER_LDFLAGS': [
+                        '-Wl,--export=emnapi_thread_crashed',
+                      ],
+                    },
+                  }],
                   ['OS != "wasi"', {
                     'defines': [
                       'PAGESIZE=65536'

package/dist/library_napi.js

@@ -61,10 +61,13 @@ function emnapiInit(options) {
         });
     }
     catch (err) {
+        if (err !== 'unwind') {
+            throw err;
+        }
+    }
+    finally {
         emnapiCtx.closeScope(envObject, scope);
-        throw err;
     }
-    emnapiCtx.closeScope(envObject, scope);
     emnapiModule.loaded = true;
     delete emnapiModule.envObject;
     return emnapiModule.exports;
@@ -75,7 +78,6 @@ function emnapiInit(options) {
 function __emnapi_async_work_pool_size() {
     return Math.abs(emnapiAsyncWorkPoolSize);
 }
-/* eslint-disable @typescript-eslint/indent */
 /**
  * @__sig ipiip
  */
@@ -180,6 +182,31 @@ function __emnapi_ctx_increase_waiting_request_counter() {
 function __emnapi_ctx_decrease_waiting_request_counter() {
     emnapiCtx.decreaseWaitingRequestCounter();
 }
+/**
+ * @__sig i
+ */
+function __emnapi_is_main_runtime_thread() {
+    return ENVIRONMENT_IS_PTHREAD ? 0 : 1;
+}
+/**
+ * @__sig i
+ */
+function __emnapi_is_main_browser_thread() {
+    return (typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE) ? 1 : 0;
+}
+/**
+ * @__sig v
+ */
+function __emnapi_unwind() {
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    throw 'unwind';
+}
+/**
+ * @__sig d
+ */
+function __emnapi_get_now() {
+    return performance.timeOrigin + performance.now();
+}
 function emnapiSetValueI64(result, numberValue) {
     var tempDouble;
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -190,6 +217,20 @@ function emnapiSetValueI64(result, numberValue) {
     {{{ makeSetValue('result', 0, 'tempI64[0]', 'i32') }}};
     {{{ makeSetValue('result', 4, 'tempI64[1]', 'i32') }}};
 }
+/**
+ * @__deps $emnapiCtx
+ * @__sig p
+ */
+function __emnapi_open_handle_scope() {
+    return emnapiCtx.openScope().id;
+}
+/**
+ * @__deps $emnapiCtx
+ * @__sig vp
+ */
+function __emnapi_close_handle_scope(_scope) {
+    return emnapiCtx.closeScope();
+}
 /* eslint-disable eqeqeq */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/indent */
@@ -942,6 +983,10 @@ var emnapiExternalMemory = {
         emnapiExternalMemory.table = new WeakMap();
         emnapiExternalMemory.wasmMemoryViewTable = new WeakMap();
     },
+    isSharedArrayBuffer: function (value) {
+        return ((typeof SharedArrayBuffer === 'function' && value instanceof SharedArrayBuffer) ||
+            (Object.prototype.toString.call(value) === '[object SharedArrayBuffer]'));
+    },
     isDetachedArrayBuffer: function (arrayBuffer) {
         if (arrayBuffer.byteLength === 0) {
             try {
@@ -1083,7 +1128,7 @@ function _napi_get_arraybuffer_info(env, arraybuffer, data, byte_length) {
     if (!arraybuffer)
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
     var handle = emnapiCtx.handleStore.get(arraybuffer);
-    if (!handle.isArrayBuffer()) {
+    if (!handle.isArrayBuffer() && !emnapiExternalMemory.isSharedArrayBuffer(handle.value)) {
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
     }
     if (data) {
@@ -2586,7 +2631,7 @@ function emnapiSyncMemory(js_to_wasm, arrayBufferOrView, offset, len) {
     offset = offset !== null && offset !== void 0 ? offset : 0;
     offset = offset >>> 0;
     var view;
-    if (arrayBufferOrView instanceof ArrayBuffer) {
+    if (arrayBufferOrView instanceof ArrayBuffer || emnapiExternalMemory.isSharedArrayBuffer(arrayBufferOrView)) {
         var pointer = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false).address;
         if (!pointer)
             throw new Error('Unknown ArrayBuffer address');
@@ -2654,7 +2699,7 @@ function _emnapi_sync_memory(env, js_to_wasm, arraybuffer_or_view, offset, len)
         {{{ from64('len') }}};
         var handleId = {{{ makeGetValue('arraybuffer_or_view', 0, '*') }}};
         var handle = envObject.ctx.handleStore.get(handleId);
-        if (!handle.isArrayBuffer() && !handle.isTypedArray() && !handle.isDataView()) {
+        if (!handle.isArrayBuffer() && !handle.isTypedArray() && !handle.isDataView() && !emnapiExternalMemory.isSharedArrayBuffer(handle.value)) {
             return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
         var ret = emnapiSyncMemory(Boolean(js_to_wasm), handle.value, offset, len);
@@ -2674,7 +2719,7 @@ function emnapiGetMemoryAddress(arrayBufferOrView) {
     var isArrayBuffer = arrayBufferOrView instanceof ArrayBuffer;
     var isDataView = arrayBufferOrView instanceof DataView;
     var isTypedArray = ArrayBuffer.isView(arrayBufferOrView) && !isDataView;
-    if (!isArrayBuffer && !isTypedArray && !isDataView) {
+    if (!isArrayBuffer && !isTypedArray && !isDataView && !emnapiExternalMemory.isSharedArrayBuffer(arrayBufferOrView)) {
         throw new TypeError('emnapiGetMemoryAddress expect ArrayBuffer or ArrayBufferView as first parameter');
     }
     var info;
@@ -2800,10 +2845,10 @@ function _napi_create_array_with_length(env, length, result) {
     {{{ makeSetValue('result', 0, 'value', '*') }}};
     return envObject.clearLastError();
 }
-function emnapiCreateArrayBuffer(byte_length, data) {
+function emnapiCreateArrayBuffer(byte_length, data, shared) {
     {{{ from64('byte_length') }}};
     byte_length = byte_length >>> 0;
-    var arrayBuffer = new ArrayBuffer(byte_length);
+    var arrayBuffer = shared ? new SharedArrayBuffer(byte_length) : new ArrayBuffer(byte_length);
     if (data) {
         {{{ from64('data') }}};
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -2832,7 +2877,37 @@ function _napi_create_arraybuffer(env, byte_length, data, result) {
         if (!result)
             return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
         {{{ from64('result') }}};
-        var arrayBuffer = emnapiCreateArrayBuffer(byte_length, data);
+        var arrayBuffer = emnapiCreateArrayBuffer(byte_length, data, false);
+        value = emnapiCtx.addToCurrentScope(arrayBuffer).id;
+        {{{ makeSetValue('result', 0, 'value', '*') }}};
+        return envObject.getReturnStatus();
+    }
+    catch (err) {
+        envObject.tryCatch.setError(err);
+        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+    }
+}
+/**
+ * @__sig ipppp
+ */
+function _node_api_create_sharedarraybuffer(env, byte_length, data, result) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var value;
+    if (!env)
+        return 1 /* napi_status.napi_invalid_arg */;
+    // @ts-expect-error
+    var envObject = emnapiCtx.envStore.get(env);
+    envObject.checkGCAccess();
+    if (!envObject.tryCatch.isEmpty())
+        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+    if (!envObject.canCallIntoJs())
+        return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);
+    envObject.clearLastError();
+    try {
+        if (!result)
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+        {{{ from64('result') }}};
+        var arrayBuffer = emnapiCreateArrayBuffer(byte_length, data, true);
         value = emnapiCtx.addToCurrentScope(arrayBuffer).id;
         {{{ makeSetValue('result', 0, 'value', '*') }}};
         return envObject.getReturnStatus();
@@ -3205,7 +3280,7 @@ function _napi_create_buffer_copy(env, length, data, result_data, result) {
         if (!Buffer) {
             throw emnapiCtx.createNotSupportBufferError('napi_create_buffer_copy', '');
         }
-        var arrayBuffer = emnapiCreateArrayBuffer(length, result_data);
+        var arrayBuffer = emnapiCreateArrayBuffer(length, result_data, false);
         var buffer = Buffer.from(arrayBuffer);
         {{{ from64('data') }}};
         {{{ from64('length') }}};
@@ -6417,6 +6492,27 @@ function _napi_is_arraybuffer(env, value, result) {
     return envObject.clearLastError();
 }
 /** @__sig ippp */
+function _node_api_is_sharedarraybuffer(env, value, result) {
+    if (!env)
+        return 1 /* napi_status.napi_invalid_arg */;
+    // @ts-expect-error
+    var envObject = emnapiCtx.envStore.get(env);
+    envObject.checkGCAccess();
+    if (!value)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    if (!result)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var h = emnapiCtx.handleStore.get(value);
+    {{{ from64('result') }}};
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var r = ((typeof SharedArrayBuffer === 'function' && h.value instanceof SharedArrayBuffer) ||
+        (Object.prototype.toString.call(h.value) === '[object SharedArrayBuffer]'))
+        ? 1
+        : 0;
+    {{{ makeSetValue('result', 0, 'r', 'i8') }}};
+    return envObject.clearLastError();
+}
+/** @__sig ippp */
 function _napi_is_date(env, value, result) {
     if (!env)
         return 1 /* napi_status.napi_invalid_arg */;
@@ -6655,6 +6751,9 @@ function _napi_get_version(env, result) {
     _emnapi_callback_into_module: __emnapi_callback_into_module,
     _emnapi_callback_into_module__deps: ["$emnapiCtx"],
     _emnapi_callback_into_module__sig: "vipppi",
+    _emnapi_close_handle_scope: __emnapi_close_handle_scope,
+    _emnapi_close_handle_scope__deps: ["$emnapiCtx", "$emnapiCtx"],
+    _emnapi_close_handle_scope__sig: "vp",
     _emnapi_ctx_decrease_waiting_request_counter: __emnapi_ctx_decrease_waiting_request_counter,
     _emnapi_ctx_decrease_waiting_request_counter__deps: ["$emnapiCtx"],
     _emnapi_ctx_decrease_waiting_request_counter__sig: "v",
@@ -6681,6 +6780,12 @@ function _napi_get_version(env, result) {
     _emnapi_get_last_error_info__sig: "vpppp",
     _emnapi_get_node_version: __emnapi_get_node_version,
     _emnapi_get_node_version__sig: "vppp",
+    _emnapi_get_now: __emnapi_get_now,
+    _emnapi_get_now__sig: "d",
+    _emnapi_is_main_browser_thread: __emnapi_is_main_browser_thread,
+    _emnapi_is_main_browser_thread__sig: "i",
+    _emnapi_is_main_runtime_thread: __emnapi_is_main_runtime_thread,
+    _emnapi_is_main_runtime_thread__sig: "i",
     _emnapi_node_emit_async_destroy: __emnapi_node_emit_async_destroy,
     _emnapi_node_emit_async_destroy__deps: ["$emnapiNodeBinding"],
     _emnapi_node_emit_async_destroy__sig: "vdd",
@@ -6690,12 +6795,17 @@ function _napi_get_version(env, result) {
     _emnapi_node_make_callback: __emnapi_node_make_callback,
     _emnapi_node_make_callback__deps: ["$emnapiNodeBinding", "$emnapiCtx"],
     _emnapi_node_make_callback__sig: "ipppppddp",
+    _emnapi_open_handle_scope: __emnapi_open_handle_scope,
+    _emnapi_open_handle_scope__deps: ["$emnapiCtx", "$emnapiCtx"],
+    _emnapi_open_handle_scope__sig: "p",
     _emnapi_runtime_keepalive_pop: __emnapi_runtime_keepalive_pop,
     _emnapi_runtime_keepalive_pop__deps: ["$runtimeKeepalivePop"],
     _emnapi_runtime_keepalive_pop__sig: "v",
     _emnapi_runtime_keepalive_push: __emnapi_runtime_keepalive_push,
     _emnapi_runtime_keepalive_push__deps: ["$runtimeKeepalivePush"],
     _emnapi_runtime_keepalive_push__sig: "v",
+    _emnapi_unwind: __emnapi_unwind,
+    _emnapi_unwind__sig: "v",
     _emnapi_worker_unref: __emnapi_worker_unref,
     _emnapi_worker_unref__deps: ["$PThread"],
     _emnapi_worker_unref__sig: "vp",
@@ -6729,7 +6839,7 @@ function _napi_get_version(env, result) {
     emnapi_is_support_weakref__deps: ["$emnapiCtx"],
     emnapi_is_support_weakref__sig: "i",
     emnapi_sync_memory: _emnapi_sync_memory,
-    emnapi_sync_memory__deps: ["$emnapiCtx", "$emnapiSyncMemory"],
+    emnapi_sync_memory__deps: ["$emnapiCtx", "$emnapiExternalMemory", "$emnapiSyncMemory"],
     emnapi_sync_memory__sig: "ipippp",
     $emnapiTSFN: emnapiTSFN,
     $emnapiTSFN__deps: ["$emnapiCtx", "_emnapi_runtime_keepalive_pop", "$emnapiNodeBinding", "_emnapi_node_emit_async_destroy", "malloc", "free"],
@@ -7177,9 +7287,15 @@ function _napi_get_version(env, result) {
     node_api_create_property_key_utf8: _node_api_create_property_key_utf8,
     node_api_create_property_key_utf8__deps: ["napi_create_string_utf8"],
     node_api_create_property_key_utf8__sig: "ipppp",
+    node_api_create_sharedarraybuffer: _node_api_create_sharedarraybuffer,
+    node_api_create_sharedarraybuffer__deps: ["$emnapiCtx", "$emnapiCreateArrayBuffer"],
+    node_api_create_sharedarraybuffer__sig: "ipppp",
     node_api_create_syntax_error: _node_api_create_syntax_error,
     node_api_create_syntax_error__deps: ["$emnapiCtx"],
     node_api_create_syntax_error__sig: "ipppp",
+    node_api_is_sharedarraybuffer: _node_api_is_sharedarraybuffer,
+    node_api_is_sharedarraybuffer__deps: ["$emnapiCtx"],
+    node_api_is_sharedarraybuffer__sig: "ippp",
     node_api_post_finalizer: _node_api_post_finalizer,
     node_api_post_finalizer__deps: ["$emnapiCtx"],
     node_api_post_finalizer__sig: "ipppp",

package/emnapi.gyp

@@ -55,6 +55,7 @@
         'src/node_api.c',
         'src/async_cleanup_hook.c',
         'src/async_context.c',
+        'src/wasi_wait.c',
       ],
       'link_settings': {
         'target_conditions': [
@@ -88,6 +89,22 @@
             ]
           },
         }],
+        ['OS == "wasi"', {
+          'link_settings': {
+            'target_conditions': [
+              ['_type == "executable"', {
+                'ldflags': [
+                  '-Wl,--export=emnapi_thread_crashed',
+                ],
+                'xcode_settings': {
+                  'OTHER_LDFLAGS': [
+                    '-Wl,--export=emnapi_thread_crashed',
+                  ],
+                },
+              }],
+            ]
+          },
+        }],
       ]
     },
     {
@@ -98,6 +115,7 @@
         'src/node_api.c',
         'src/async_cleanup_hook.c',
         'src/async_context.c',
+        'src/wasi_wait.c',
 
         'src/uv/uv-common.c',
         'src/uv/threadpool.c',

package/include/node/emnapi.h

@@ -6,8 +6,8 @@
 #include "emnapi_common.h"
 
 #define EMNAPI_MAJOR_VERSION 1
-#define EMNAPI_MINOR_VERSION 4
-#define EMNAPI_PATCH_VERSION 5
+#define EMNAPI_MINOR_VERSION 6
+#define EMNAPI_PATCH_VERSION 0
 
 typedef enum {
   emnapi_runtime,

package/include/node/js_native_api.h

@@ -358,7 +358,7 @@ napi_create_reference(napi_env env,
 
 // Deletes a reference. The referenced value is released, and may
 // be GC'd unless there are other references to it.
-NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(napi_env env,
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(node_api_basic_env env,
                                                          napi_ref ref);
 
 // Increments the reference count, optionally returning the resulting count.
@@ -480,6 +480,14 @@ napi_get_dataview_info(napi_env env,
                        napi_value* arraybuffer,
                        size_t* byte_offset);
 
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_SHAREDARRAYBUFFER
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_is_sharedarraybuffer(napi_env env, napi_value value, bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_sharedarraybuffer(
+    napi_env env, size_t byte_length, void** data, napi_value* result);
+#endif  // NAPI_EXPERIMENTAL
+
 // version management
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
                                                     uint32_t* result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "1.4.5",
+  "version": "1.6.0",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "gypfile": false,

package/src/emnapi_internal.h

@@ -98,11 +98,18 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_runtime_keepalive_pop();
 #define EMNAPI_KEEPALIVE_POP _emnapi_runtime_keepalive_pop
 #endif
 
+EMNAPI_INTERNAL_EXTERN napi_handle_scope _emnapi_open_handle_scope();
+EMNAPI_INTERNAL_EXTERN void _emnapi_close_handle_scope(napi_handle_scope scope);
 EMNAPI_INTERNAL_EXTERN void _emnapi_env_ref(napi_env env);
 EMNAPI_INTERNAL_EXTERN void _emnapi_env_unref(napi_env env);
 EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_increase_waiting_request_counter();
 EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_decrease_waiting_request_counter();
 
+EMNAPI_INTERNAL_EXTERN int _emnapi_is_main_browser_thread();
+EMNAPI_INTERNAL_EXTERN int _emnapi_is_main_runtime_thread();
+EMNAPI_INTERNAL_EXTERN double _emnapi_get_now();
+EMNAPI_INTERNAL_EXTERN void _emnapi_unwind();
+
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 #define EMNAPI_HAVE_THREADS 1
 #else

package/src/threadsafe_function.c

@@ -136,6 +136,8 @@ static void _emnapi_tsfn_destroy(napi_threadsafe_function func) {
     EMNAPI_ASSERT_CALL(napi_delete_reference(func->env, func->ref));
   }
 
+  EMNAPI_ASYNC_RESOURCE_DTOR(func->env, (emnapi_async_resource*) func);
+
   EMNAPI_ASSERT_CALL(napi_remove_env_cleanup_hook(func->env, _emnapi_tsfn_cleanup, func));
   _emnapi_env_unref(func->env);
   if (func->async_ref) {
@@ -144,7 +146,6 @@ static void _emnapi_tsfn_destroy(napi_threadsafe_function func) {
     func->async_ref = false;
   }
 
-  EMNAPI_ASYNC_RESOURCE_DTOR(func->env, (emnapi_async_resource*) func);
   free(func);
 }
 
@@ -209,8 +210,7 @@ static napi_value _emnapi_tsfn_finalize_in_callback_scope(napi_env env, napi_cal
 }
 
 static void _emnapi_tsfn_finalize(napi_threadsafe_function func) {
-  napi_handle_scope scope;
-  EMNAPI_ASSERT_CALL(napi_open_handle_scope(func->env, &scope));
+  napi_handle_scope scope = _emnapi_open_handle_scope();
   if (func->finalize_cb) {
     if (emnapi_is_node_binding_available()) {
       napi_value resource, cb;
@@ -229,7 +229,7 @@ static void _emnapi_tsfn_finalize(napi_threadsafe_function func) {
     }
   }
   _emnapi_tsfn_empty_queue_and_delete(func);
-  EMNAPI_ASSERT_CALL(napi_close_handle_scope(func->env, scope));
+  _emnapi_close_handle_scope(scope);
 }
 
 static void _emnapi_tsfn_do_finalize(uv_handle_t* data) {

package/src/wasi_wait.c

@@ -0,0 +1,106 @@
+#if defined(__wasi__)
+
+#include <time.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include "emnapi_internal.h"
+
+struct __pthread {
+  unsigned char _[32];
+  volatile int cancel;
+  volatile unsigned char canceldisable, cancelasync;
+	unsigned char tsd_used:1;
+	unsigned char dlerror_flag:1;
+  unsigned char __[68];
+};
+
+#define INFINITY __builtin_inff()
+
+int __wasilibc_futex_wait_atomic_wait(volatile void *addr, int op, int val, int64_t max_wait_ns);
+
+static _Atomic pthread_t crashed_thread_id = NULL;
+
+__attribute__((visibility("default")))
+void emnapi_thread_crashed() {
+  crashed_thread_id = pthread_self();
+}
+
+void _emnapi_yield() {
+  if (crashed_thread_id) {
+    _emnapi_runtime_keepalive_push();
+    _emnapi_unwind();
+  }
+}
+
+static int _emnapi_wait_main_browser_thread(int is_runtime_thread, volatile void *addr, int op, int val, double max_wait_ms) {
+  double now = _emnapi_get_now();
+  double end = now + max_wait_ms;
+
+  while (1) {
+    now = _emnapi_get_now();
+    if (now >= end) {
+      return -ETIMEDOUT;
+    }
+
+    if (is_runtime_thread) {
+      _emnapi_yield();
+    }
+
+    if (__c11_atomic_load((_Atomic int *)addr, __ATOMIC_SEQ_CST) != val) {
+      break;
+    }
+  }
+
+  return 0;
+}
+
+int _emnapi_wait(int is_runtime_thread, volatile void *addr, int op, int val, double max_wait_ms) {
+  if (is_runtime_thread) {
+    _emnapi_yield();
+  }
+
+  // https://github.com/WebAssembly/wasi-libc/blob/3f7eb4c7d6ede4dde3c4bffa6ed14e8d656fe93f/libc-top-half/musl/src/thread/wasm32/__wasilibc_busywait.c#L42
+  if (!_emnapi_is_main_browser_thread()) {
+    int64_t max_wait_ns = -1;
+    if (max_wait_ms != INFINITY) {
+      max_wait_ns = (int64_t)(max_wait_ms*1000*1000);
+    }
+    return __wasilibc_futex_wait_atomic_wait(addr, op, val, max_wait_ns);
+  }
+
+  return _emnapi_wait_main_browser_thread(is_runtime_thread, addr, op, val, max_wait_ms);
+}
+
+int __wasilibc_futex_wait_maybe_busy(volatile void *addr, int op, int val, int64_t max_wait_ns) {
+  // https://github.com/emscripten-core/emscripten/blob/89ce854a99238d04116a3d9b5afe241eec90c6c3/system/lib/libc/musl/src/thread/__timedwait.c#L60
+  int r = 0;
+  double msecsToSleep = max_wait_ns >= 0 ? (max_wait_ns / 1000000.0) : INFINITY;
+  int is_runtime_thread = _emnapi_is_main_runtime_thread();
+	double max_ms_slice_to_sleep = is_runtime_thread ? 1 : 100;
+
+  if (is_runtime_thread ||
+	    pthread_self()->canceldisable != PTHREAD_CANCEL_DISABLE ||
+	    pthread_self()->cancelasync) {
+    double sleepUntilTime = _emnapi_get_now() + msecsToSleep;
+		do {
+      if (pthread_self()->cancel) {
+				pthread_testcancel();
+				return ECANCELED;
+			}
+			msecsToSleep = sleepUntilTime - _emnapi_get_now();
+			if (msecsToSleep <= 0) {
+				r = ETIMEDOUT;
+				break;
+			}
+			if (msecsToSleep > max_ms_slice_to_sleep)
+				msecsToSleep = max_ms_slice_to_sleep;
+			r = -_emnapi_wait(is_runtime_thread, (void*)addr, op, val, msecsToSleep);
+		} while (r == ETIMEDOUT);
+  } else {
+    r = -_emnapi_wait(is_runtime_thread, (void*)addr, op, val, msecsToSleep);
+  }
+  return r;
+}
+
+#endif