emnapi 0.32.2 → 0.33.1

package/CMakeLists.txt

@@ -44,7 +44,7 @@ set(EMNAPI_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/include")
 set(EMNAPI_JS_LIB "${CMAKE_CURRENT_SOURCE_DIR}/dist/library_napi.js")
 
 if(IS_EMSCRIPTEN)
-  set(EMNAPI_MT_CFLAGS "-sUSE_PTHREADS=1" "-sWASM_WORKERS=1")
+  set(EMNAPI_MT_CFLAGS "-pthread" "-sWASM_WORKERS=1")
 else()
   set(EMNAPI_MT_CFLAGS "-pthread")
 endif()
@@ -148,7 +148,7 @@ if(LIB_ARCH)
 endif()
 
 install(FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/common.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/emnapi_common.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/emnapi.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/js_native_api_types.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/js_native_api.h
@@ -170,7 +170,7 @@ install(FILES
 if(EMNAPI_INSTALL_SRC)
   install(FILES
       ${EMNAPI_SRC}
-      "${CMAKE_CURRENT_SOURCE_DIR}/src/emnapi_common.h"
+      "${CMAKE_CURRENT_SOURCE_DIR}/src/emnapi_internal.h"
     DESTINATION "src/${PROJECT_NAME}")
   install(DIRECTORY
     ${CMAKE_CURRENT_SOURCE_DIR}/src/uv

package/README.md

@@ -6,9 +6,7 @@
 
 [![Build](https://github.com/toyobayashi/emnapi/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/toyobayashi/emnapi/actions/workflows/main.yml)
 
-[Node-API](https://nodejs.org/docs/latest/api/n-api.html) implementation for [Emscripten](https://emscripten.org/index.html), [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) and clang `wasm32-unknown-unknown` target, [napi-rs support is comming soon](https://github.com/napi-rs/napi-rs/issues/796).
-
-Emscripten is the first class support target, currently thread related APIs are unavailable on `wasm32-unknown-unknown` and `wasm32-wasi` target.
+[Node-API](https://nodejs.org/docs/latest/api/n-api.html) implementation for [Emscripten](https://emscripten.org/index.html), [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) and clang with wasm support. [napi-rs support is comming soon](https://github.com/napi-rs/napi-rs/tree/emnapi).
 
 This project aims to
 
@@ -27,6 +25,16 @@ See documentation for more details:
 
 [How to build Node-API official examples](https://github.com/toyobayashi/node-addon-examples)
 
+Emscripten is the first class support target. If your target is running addon on browser,
+we strongly recommend you to use Emscripten instead of wasi-sdk. Async works and threadsafe
+functions related APIs are only available on Emscripten or `wasm32-wasi-threads` target since
+they are relying on pthread. Though today we have [WASI browser polyfill](https://github.com/toyobayashi/wasm-util),
+`wasm32-wasi-threads` is in very early stage and WASI itself is not designed for browser.
+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.
+
 ## Prerequests
 
 You will need to install:
@@ -332,30 +340,19 @@ For non-emscripten, you need to use `@emnapi/core`. The initialization is simila
 <script src="node_modules/@emnapi/runtime/dist/emnapi.min.js"></script>
 <script src="node_modules/@emnapi/core/dist/emnapi-core.min.js"></script>
 <script>
-const napiModule = emnapiCore.createNapiModule({
-  context: emnapi.getDefaultContext()
-})
-
-fetch('./hello.wasm').then(res => res.arrayBuffer()).then(wasmBuffer => {
-  return WebAssembly.instantiate(wasmBuffer, {
-    env: {
-      ...napiModule.imports.env,
-      // Currently napi-rs imports all symbols from env module
-      ...napiModule.imports.napi,
-      ...napiModule.imports.emnapi
-    },
-    // clang
-    napi: napiModule.imports.napi,
-    emnapi: napiModule.imports.emnapi
-  })
-}).then(({ instance, module }) => {
-  const binding = napiModule.init({
-    instance, // WebAssembly.Instance
-    module, // WebAssembly.Module
-    memory: instance.exports.memory, // WebAssembly.Memory
-    table: instance.exports.__indirect_function_table // WebAssembly.Table
-  })
-  // binding === napiModule.exports
+emnapiCore.instantiateNapiModule(fetch('./hello.wasm'), {
+  context: emnapi.getDefaultContext(),
+  overwriteImports (importObject) {
+    // importObject.env = {
+    //   ...importObject.env,
+    //   ...importObject.napi,
+    //   ...importObject.emnapi,
+    //   // ...
+    // }
+  }
+}).then(({ instance, module, napiModule }) => {
+  const binding = napiModule.exports
+  // ...
 })
 </script>
 ```
@@ -363,36 +360,25 @@ fetch('./hello.wasm').then(res => res.arrayBuffer()).then(wasmBuffer => {
 Using WASI on Node.js
 
 ```js
-const { createNapiModule } = require('@emnapi/core')
+const { instantiateNapiModule } = require('@emnapi/core')
 const { getDefaultContext } = require('@emnapi/runtime')
 const { WASI } = require('wasi')
-
-const napiModule = createNapiModule({
-  context: getDefaultContext()
-})
-
-const wasi = new WASI({ /* ... */ })
-
-WebAssembly.instantiate(require('fs').readFileSync('./hello.wasm'), {
-  wasi_snapshot_preview1: wasi.wasiImport,
-  env: {
-    ...napiModule.imports.env,
-    // Currently napi-rs imports all symbols from env module
-    ...napiModule.imports.napi,
-    ...napiModule.imports.emnapi
-  },
-  // clang
-  napi: napiModule.imports.napi,
-  emnapi: napiModule.imports.emnapi
-}).then(({ instance, module }) => {
-  wasi.initialize(instance)
-  const binding = napiModule.init({
-    instance,
-    module,
-    memory: instance.exports.memory,
-    table: instance.exports.__indirect_function_table
-  })
-  // binding === napiModule.exports
+const fs = require('fs')
+
+instantiateNapiModule(fs.promises.readFile('./hello.wasm'), {
+  wasi: new WASI({ /* ... */ }),
+  context: getDefaultContext(),
+  overwriteImports (importObject) {
+    // importObject.env = {
+    //   ...importObject.env,
+    //   ...importObject.napi,
+    //   ...importObject.emnapi,
+    //   // ...
+    // }
+  }
+}).then(({ instance, module, napiModule }) => {
+  const binding = napiModule.exports
+  // ...
 })
 ```
 
@@ -400,38 +386,26 @@ Using WASI on browser, you can use WASI polyfill in [wasm-util](https://github.c
 and [memfs-browser](https://github.com/toyobayashi/memfs-browser)
 
 ```js
-import { createNapiModule } from '@emnapi/core'
+import { instantiateNapiModule } from '@emnapi/core'
 import { getDefaultContext } from '@emnapi/runtime'
 import { WASI } from '@tybys/wasm-util'
-import { Volumn, createFsFromVolume } from 'memfs-browser'
-
-const napiModule = createNapiModule({
-  context: getDefaultContext()
-})
-
-const fs = createFsFromVolume(Volume.from({ /* ... */ }))
-const wasi = new WASI({ fs, /* ... */ })
-
-WebAssembly.instantiate(wasmBuffer, {
-  wasi_snapshot_preview1: wasi.wasiImport,
-  env: {
-    ...napiModule.imports.env,
-    // Currently napi-rs imports all symbols from env module
-    ...napiModule.imports.napi,
-    ...napiModule.imports.emnapi
-  },
-  // clang
-  napi: napiModule.imports.napi,
-  emnapi: napiModule.imports.emnapi
-}).then(({ instance, module }) => {
-  wasi.initialize(instance)
-  const binding = napiModule.init({
-    instance,
-    module,
-    memory: instance.exports.memory,
-    table: instance.exports.__indirect_function_table
-  })
-  // binding === napiModule.exports
+import { Volume, createFsFromVolume } from 'memfs-browser'
+
+const fs = createFsFromVolume(Volume.fromJSON({ /* ... */ }))
+return instantiateNapiModule(fetch('./hello.wasm'), {
+  wasi: new WASI({ fs, /* ... */ })
+  context: getDefaultContext(),
+  overwriteImports (importObject) {
+    // importObject.env = {
+    //   ...importObject.env,
+    //   ...importObject.napi,
+    //   ...importObject.emnapi,
+    //   // ...
+    // }
+  }
+}).then(({ instance, module, napiModule }) => {
+  const binding = napiModule.exports
+  // ...
 })
 ```
 
@@ -495,6 +469,7 @@ clang++ -O3 \
         -L./node_modules/emnapi/lib/wasm32-wasi \
         --target=wasm32-wasi \
         --sysroot=$WASI_SDK_PATH/share/wasi-sysroot \
+        -fno-exceptions \
         -mexec-model=reactor \
         -Wl,--initial-memory=16777216 \
         -Wl,--export-dynamic \
@@ -522,6 +497,7 @@ clang++ -O3 \
         -I./node_modules/emnapi/include \
         -L./node_modules/emnapi/lib/wasm32 \
         --target=wasm32 \
+        -fno-exceptions \
         -nostdlib \
         -Wl,--no-entry \
         -Wl,--initial-memory=16777216 \
@@ -575,12 +551,14 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
     "-sEXPORTED_FUNCTIONS=['_malloc','_free']"
   )
 elseif(CMAKE_SYSTEM_NAME STREQUAL "WASI")
+  set_target_properties(hello PROPERTIES SUFFIX ".wasm")
   target_link_options(hello PRIVATE
     "-mexec-model=reactor"
     "-Wl,--export=napi_register_wasm_v1"
     "-Wl,--initial-memory=16777216,--export-dynamic,--export=malloc,--export=free,--import-undefined,--export-table"
   )
 elseif((CMAKE_C_COMPILER_TARGET STREQUAL "wasm32") OR (CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-unknown-unknown"))
+  set_target_properties(hello PROPERTIES SUFFIX ".wasm")
   target_link_options(hello PRIVATE
     "-nostdlib"
     "-Wl,--export=napi_register_wasm_v1"
@@ -752,35 +730,162 @@ pub unsafe extern "C" fn napi_register_wasm_v1(env: napi_env, exports: napi_valu
 
 </details>
 
-### Multithread (Emscripten Only)
+### Multithread
 
 If you want to use async work or thread safe functions,
 there are additional C source file need to be compiled and linking.
 Recommend use CMake directly.
 
+**This is EXPERIMENTAL on non-emscripten.**
+
 ```cmake
 add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/node_modules/emnapi")
 
 add_executable(hello hello.c)
 
 target_link_libraries(hello emnapi-mt)
-target_compile_options(hello PRIVATE "-sUSE_PTHREADS=1")
-target_link_options(hello PRIVATE
-  "-sALLOW_MEMORY_GROWTH=1"
-  "-sEXPORTED_FUNCTIONS=['_malloc','_free']"
-  "-sUSE_PTHREADS=1"
-  "-sPTHREAD_POOL_SIZE=4"
-  # try to specify stack size if you experience pthread errors
-  "-sSTACK_SIZE=2MB"
-  "-sDEFAULT_PTHREAD_STACK_SIZE=2MB"
-)
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  target_compile_options(hello PRIVATE "-pthread")
+  target_link_options(hello PRIVATE
+    "-sALLOW_MEMORY_GROWTH=1"
+    "-sEXPORTED_FUNCTIONS=['_malloc','_free']"
+    "-pthread"
+    "-sPTHREAD_POOL_SIZE=4"
+    # try to specify stack size if you experience pthread errors
+    "-sSTACK_SIZE=2MB"
+    "-sDEFAULT_PTHREAD_STACK_SIZE=2MB"
+  )
+elseif(CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi-threads")
+  # Experimental
+  set_target_properties(hello PROPERTIES SUFFIX ".wasm")
+  target_compile_options(hello PRIVATE "-fno-exceptions" "-pthread")
+  target_link_options(hello PRIVATE
+    "-pthread"
+    "-mexec-model=reactor"
+    "-Wl,--import-memory"
+    "-Wl,--max-memory=2147483648"
+    "-Wl,--export-dynamic"
+    "-Wl,--export=malloc"
+    "-Wl,--export=free"
+    "-Wl,--import-undefined"
+    "-Wl,--export-table"
+  )
+endif()
 ```
 
 ```bash
+# emscripten
 emcmake cmake -DCMAKE_BUILD_TYPE=Release -DEMNAPI_WORKER_POOL_SIZE=4 -G Ninja -H. -Bbuild
+
+# wasi-sdk with thread support (Experimental)
+cmake -DCMAKE_TOOLCHAIN_FILE=$WASI_SDK_PATH/share/cmake/wasi-sdk-pthread.cmake \
+      -DWASI_SDK_PREFIX=$WASI_SDK_PATH \
+      -DCMAKE_BUILD_TYPE=Release \
+      -G Ninja -H. -Bbuild
+
 cmake --build build
 ```
 
+And additional work is required during instantiating wasm compiled with non-emscripten.
+
+```js
+// emnapi main thread (could be in a Worker)
+instantiateNapiModule(input, {
+  context: getDefaultContext(),
+  wasi: new WASI(/* ... */),
+  // reuseWorker: true,
+  onCreateWorker () {
+    return new Worker('./worker.js')
+    // Node.js
+    // const { Worker } = require('worker_threads')
+    // return new Worker(join(__dirname, './worker.js'), {
+    //   env: process.env,
+    //   execArgv: ['--experimental-wasi-unstable-preview1']
+    // })
+  },
+  overwriteImports (importObject) {
+    importObject.env.memory = new WebAssembly.Memory({
+      initial: 16777216 / 65536,
+      maximum: 2147483648 / 65536,
+      shared: true
+    })
+  }
+})
+```
+
+```js
+// worker.js
+(function () {
+  let fs, WASI, emnapiCore
+
+  const ENVIRONMENT_IS_NODE =
+    typeof process === 'object' && process !== null &&
+    typeof process.versions === 'object' && process.versions !== null &&
+    typeof process.versions.node === 'string'
+
+  if (ENVIRONMENT_IS_NODE) {
+    const nodeWorkerThreads = require('worker_threads')
+
+    const parentPort = nodeWorkerThreads.parentPort
+
+    parentPort.on('message', (data) => {
+      globalThis.onmessage({ data })
+    })
+
+    fs = require('fs')
+
+    Object.assign(globalThis, {
+      self: globalThis,
+      require,
+      Worker: nodeWorkerThreads.Worker,
+      importScripts: function (f) {
+        (0, eval)(fs.readFileSync(f, 'utf8') + '//# sourceURL=' + f)
+      },
+      postMessage: function (msg) {
+        parentPort.postMessage(msg)
+      }
+    })
+
+    WASI = require('./wasi').WASI
+    emnapiCore = require('@emnapi/core')
+  } else {
+    importScripts('./node_modules/memfs-browser/dist/memfs.js')
+    importScripts('./node_modules/@tybys/wasm-util/dist/wasm-util.min.js')
+    importScripts('./node_modules/@emnapi/core/dist/emnapi-core.js')
+    emnapiCore = globalThis.emnapiCore
+
+    const { Volume, createFsFromVolume } = memfs
+    fs = createFsFromVolume(Volume.fromJSON({
+      '/': null
+    }))
+
+    WASI = globalThis.wasmUtil.WASI
+  }
+
+  const { instantiateNapiModuleSync, MessageHandler } = emnapiCore
+
+  const handler = new MessageHandler({
+    onLoad ({ wasmModule, wasmMemory }) {
+      const wasi = new WASI({ fs })
+
+      return instantiateNapiModuleSync(wasmModule, {
+        childThread: true,
+        wasi,
+        overwriteImports (importObject) {
+          importObject.env.memory = wasmMemory
+        }
+      })
+    }
+  })
+
+  globalThis.onmessage = function (e) {
+    handler.handle(e)
+    // handle other messages
+  }
+})()
+```
+
 ## Preprocess Macro Options
 
 ### `-DEMNAPI_WORKER_POOL_SIZE=4`
@@ -794,6 +899,13 @@ Module.preRun.push(function () {
     ENV.UV_THREADPOOL_SIZE = '2';
   }
 });
+
+// wasi
+new WASI({
+  env: {
+    UV_THREADPOOL_SIZE: '2'
+  }
+})
 ```
 
 It represent max of `EMNAPI_WORKER_POOL_SIZE` async work (`napi_queue_async_work`) can be executed in parallel. Default is not defined, read `UV_THREADPOOL_SIZE` at runtime.
@@ -802,7 +914,7 @@ You can set both `PTHREAD_POOL_SIZE` and `EMNAPI_WORKER_POOL_SIZE` to `number of
 If you use another library function which may create `N` child threads in async work,
 then you need to set `PTHREAD_POOL_SIZE` to `EMNAPI_WORKER_POOL_SIZE * (N + 1)`.
 
-This option only has effect if you use `-sUSE_PTHREADS`.
+This option only has effect if you use `-pthread`.
 Emnapi will create `EMNAPI_WORKER_POOL_SIZE` threads when initializing,
 it will throw error if `PTHREAD_POOL_SIZE < EMNAPI_WORKER_POOL_SIZE && PTHREAD_POOL_SIZE_STRICT == 2`.
 
@@ -810,7 +922,7 @@ See [Issue #8](https://github.com/toyobayashi/emnapi/issues/8) for more detail.
 
 ### `-DEMNAPI_NEXTTICK_TYPE=0`
 
-This option only has effect if you use `-sUSE_PTHREADS`, Default is `0`.
+This option only has effect if you use `-pthread`, Default is `0`.
 Tell emnapi how to delay async work in `uv_async_send` / `uv__async_close`.
 
 - `0`: Use `setImmediate()` (Node.js native `setImmediate` or browser `MessageChannel` and `port.postMessage`)
@@ -818,7 +930,7 @@ Tell emnapi how to delay async work in `uv_async_send` / `uv__async_close`.
 
 ### `-DEMNAPI_USE_PROXYING=1`
 
-This option only has effect if you use `-sUSE_PTHREADS`. Default is `1` if emscripten version `>= 3.1.9`, else `0`.
+This option only has effect if you use emscripten `-pthread`. Default is `1` if emscripten version `>= 3.1.9`, else `0`.
 
 - `0`
 

package/dist/library_napi.js

@@ -1458,7 +1458,9 @@ var emnapiExternalMemory = {
             }
             return view;
         }
-        if (emnapiExternalMemory.isDetachedArrayBuffer(view.buffer) && emnapiExternalMemory.wasmMemoryViewTable.has(view)) {
+        var maybeOldWasmMemory = emnapiExternalMemory.isDetachedArrayBuffer(view.buffer) ||
+            ((typeof SharedArrayBuffer === 'function') && (view.buffer instanceof SharedArrayBuffer));
+        if (maybeOldWasmMemory && emnapiExternalMemory.wasmMemoryViewTable.has(view)) {
             var info = emnapiExternalMemory.wasmMemoryViewTable.get(view);
             var Ctor = info.Ctor;
             var newView = void 0;
@@ -4667,29 +4669,41 @@ mergeInto(LibraryManager.library, {
         'return r;' +
         '}; })();',
     $emnapiAddSendListener: function (worker) {
-        if (worker && !worker._emnapiSendListener) {
-            worker._emnapiSendListener = function _emnapiSendListener(e) {
-                var data = ENVIRONMENT_IS_NODE ? e : e.data;
-                if (data.emnapiAsyncSend) {
-                    if (ENVIRONMENT_IS_PTHREAD) {
-                        postMessage({
-                            emnapiAsyncSend: data.emnapiAsyncSend
-                        });
-                    }
-                    else {
-                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                        var callback = data.emnapiAsyncSend.callback;
-                        {{{ makeDynCall('vp', 'callback') }}}(data.emnapiAsyncSend.data);
-                    }
+        if (!worker)
+            return false;
+        if (worker._emnapiSendListener)
+            return true;
+        var handler = function (e) {
+            var data = ENVIRONMENT_IS_NODE ? e : e.data;
+            var __emnapi__ = data.__emnapi__;
+            if (__emnapi__ && __emnapi__.type === 'async-send') {
+                if (ENVIRONMENT_IS_PTHREAD) {
+                    postMessage({ __emnapi__: __emnapi__ });
                 }
-            };
+                else {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    var callback = __emnapi__.payload.callback;
+                    {{{ makeDynCall('vp', 'callback') }}}(__emnapi__.payload.data);
+                }
+            }
+        };
+        var dispose = function () {
             if (ENVIRONMENT_IS_NODE) {
-                worker.on('message', worker._emnapiSendListener);
+                worker.off('message', handler);
             }
             else {
-                worker.addEventListener('message', worker._emnapiSendListener, false);
+                worker.removeEventListener('message', handler, false);
             }
+            delete worker._emnapiSendListener;
+        };
+        worker._emnapiSendListener = { handler: handler, dispose: dispose };
+        if (ENVIRONMENT_IS_NODE) {
+            worker.on('message', handler);
         }
+        else {
+            worker.addEventListener('message', handler, false);
+        }
+        return true;
     },
     _emnapi_async_send_js__sig: 'vipp',
     _emnapi_async_send_js__deps: [
@@ -4700,9 +4714,12 @@ mergeInto(LibraryManager.library, {
     _emnapi_async_send_js: function (type, callback, data) {
         if (ENVIRONMENT_IS_PTHREAD) {
             postMessage({
-                emnapiAsyncSend: {
-                    callback: callback,
-                    data: data
+                __emnapi__: {
+                    type: 'async-send',
+                    payload: {
+                        callback: callback,
+                        data: data
+                    }
                 }
             });
         }
@@ -4968,14 +4985,14 @@ function emnapiImplement(name, sig, compilerTimeFunction, deps) {
     mergeInto(LibraryManager.library, sym);
 }
 function emnapiImplement2() {
-    return emnapiImplement.apply(null, arguments);
+    emnapiImplement.apply(null, arguments);
 }
 function emnapiImplementInternal() {
-    return emnapiImplement.apply(null, arguments);
+    emnapiImplement.apply(null, arguments);
 }
 // $emnapi*
 function emnapiImplementHelper(name, sig, compilerTimeFunction, deps, _exportName) {
-    return emnapiImplement(name, sig, compilerTimeFunction, deps);
+    emnapiImplement(name, sig, compilerTimeFunction, deps);
 }
 function emnapiDefineVar(name, value, deps, postset) {
     var _a;

package/include/emnapi.h

@@ -2,7 +2,7 @@
 #define EMNAPI_INCLUDE_EMNAPI_H_
 
 #include "js_native_api.h"
-#include "common.h"
+#include "emnapi_common.h"
 
 typedef enum {
   emnapi_runtime,

package/include/js_native_api.h

@@ -22,7 +22,7 @@
 #endif
 
 #include "js_native_api_types.h"
-#include "common.h"
+#include "emnapi_common.h"
 
 #define NAPI_AUTO_LENGTH SIZE_MAX
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "0.32.2",
+  "version": "0.33.1",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "devDependencies": {

package/src/async_cleanup_hook.c

@@ -1,4 +1,4 @@
-#include "emnapi_common.h"
+#include "emnapi_internal.h"
 #include "node_api.h"
 
 EXTERN_C_START

package/src/async_context.c

@@ -1,5 +1,5 @@
 #include <node_api.h>
-#include "emnapi_common.h"
+#include "emnapi_internal.h"
 
 EXTERN_C_START
 

package/src/async_work.c

@@ -1,5 +1,5 @@
 #include "node_api.h"
-#include "emnapi_common.h"
+#include "emnapi_internal.h"
 
 #if EMNAPI_HAVE_THREADS
 

package/src/emnapi.c

@@ -1,4 +1,4 @@
-#include "emnapi_common.h"
+#include "emnapi_internal.h"
 
 EXTERN_C_START
 

package/src/js_native_api.c

@@ -1,4 +1,4 @@
-#include "emnapi_common.h"
+#include "emnapi_internal.h"
 
 #ifdef __EMSCRIPTEN__
 #include <emscripten/heap.h>

package/src/node_api.c

@@ -1,4 +1,4 @@
-#include "emnapi_common.h"
+#include "emnapi_internal.h"
 #include "node_api.h"
 
 #if EMNAPI_HAVE_THREADS

package/src/threadsafe_function.c

@@ -1,5 +1,5 @@
 #include "node_api.h"
-#include "emnapi_common.h"
+#include "emnapi_internal.h"
 
 #if NAPI_VERSION >= 4 && EMNAPI_HAVE_THREADS
 #include <stdatomic.h>

package/src/uv/threadpool.c

@@ -27,7 +27,11 @@
 #include <errno.h>
 #include <string.h>
 #include "uv-common.h"
-#include "common.h"
+#include "emnapi_common.h"
+
+#if defined(__wasi__) && defined(_REENTRANT)
+#define __EMNAPI_WASI_THREADS__
+#endif
 
 #define MAX_THREADPOOL_SIZE 1024
 
@@ -54,6 +58,15 @@ static void uv__cancelled(struct uv__work* w) {
 
 EMNAPI_INTERNAL_EXTERN void _emnapi_worker_unref(uv_thread_t pid);
 
+#ifdef __EMNAPI_WASI_THREADS__
+EMNAPI_INTERNAL_EXTERN
+void _emnapi_after_uvthreadpool_ready(void (*callback)(QUEUE* w, enum uv__work_kind kind),
+                                      QUEUE* w,
+                                      enum uv__work_kind kind);
+EMNAPI_INTERNAL_EXTERN void _emnapi_tell_js_uvthreadpool(uv_thread_t* threads, unsigned int n);
+EMNAPI_INTERNAL_EXTERN void _emnapi_emit_async_thread_ready();
+#endif
+
 /* To avoid deadlock with uv_cancel() it's crucial that the worker
  * never holds the global mutex and the loop-local mutex at the same time.
  */
@@ -61,8 +74,11 @@ static void* worker(void* arg) {
   struct uv__work* w;
   QUEUE* q;
   int is_slow_work;
-
+#ifndef __EMNAPI_WASI_THREADS__
   uv_sem_post((uv_sem_t*) arg);
+#else
+  _emnapi_emit_async_thread_ready();
+#endif
   arg = NULL;
 
   uv_mutex_lock(&mutex);
@@ -199,7 +215,9 @@ static void init_threads(void) {
 #if !defined(EMNAPI_WORKER_POOL_SIZE) || !(EMNAPI_WORKER_POOL_SIZE > 0)
   const char* val;
 #endif
+#ifndef __EMNAPI_WASI_THREADS__
   uv_sem_t sem;
+#endif
 
 #if defined(EMNAPI_WORKER_POOL_SIZE) && EMNAPI_WORKER_POOL_SIZE > 0
   nthreads = EMNAPI_WORKER_POOL_SIZE;
@@ -233,24 +251,33 @@ static void init_threads(void) {
   QUEUE_INIT(&slow_io_pending_wq);
   QUEUE_INIT(&run_slow_work_message);
 
+#ifndef __EMNAPI_WASI_THREADS__
   if (uv_sem_init(&sem, 0))
     abort();
+#endif
 
   for (i = 0; i < nthreads; i++)
+#ifndef __EMNAPI_WASI_THREADS__
     if (uv_thread_create(threads + i, (uv_thread_cb) worker, &sem))
+#else
+    if (uv_thread_create(threads + i, (uv_thread_cb) worker, NULL))
+#endif
       abort();
 
+#ifndef __EMNAPI_WASI_THREADS__
   for (i = 0; i < nthreads; i++)
     uv_sem_wait(&sem);
 
   uv_sem_destroy(&sem);
-
   for (i = 0; i < nthreads; i++)
     _emnapi_worker_unref(*(threads + i));
+#else
+  _emnapi_tell_js_uvthreadpool(threads, nthreads);
+#endif
 }
 
 
-#ifndef _WIN32
+#if !defined(_WIN32) && !defined(__wasi__)
 static void reset_once(void) {
   uv_once_t child_once = UV_ONCE_INIT;
   memcpy(&once, &child_once, sizeof(child_once));
@@ -259,7 +286,7 @@ static void reset_once(void) {
 
 
 static void init_once(void) {
-#ifndef _WIN32
+#if !defined(_WIN32) && !defined(__wasi__)
   /* Re-initialize the threadpool after fork.
    * Note that this discards the global mutex and condition as well
    * as the work queue.
@@ -280,7 +307,11 @@ void uv__work_submit(uv_loop_t* loop,
   w->loop = loop;
   w->work = work;
   w->done = done;
+// #ifdef __EMNAPI_WASI_THREADS__
+//   _emnapi_after_uvthreadpool_ready(post, &w->wq, kind);
+// #else
   post(&w->wq, kind);
+// #endif
 }
 
 

package/src/uv/unix/async.c

@@ -27,7 +27,7 @@
 #include <stdlib.h>
 #include <sched.h>
 #include "../uv-common.h"
-#include "common.h"
+#include "emnapi_common.h"
 
 #if defined(__clang__) ||                                                     \
     defined(__GNUC__) ||                                                      \

package/src/uv/unix/thread.c

@@ -6,6 +6,15 @@
 #include <time.h>
 #include "uv.h"
 
+// #define CHECK_RET(the_call) \
+//   do { \
+//     int r = (the_call); \
+//     if (r) { \
+//       fprintf(stderr, #the_call ": %d\n", r); \
+//       abort(); \
+//     } \
+//   } while (0)
+
 void uv_sem_post(sem_t* sem) {
   if (sem_post(sem))
     abort();
@@ -39,7 +48,7 @@ void uv_once(pthread_once_t* guard, void (*callback)(void)) {
 }
 
 int uv_mutex_init(uv_mutex_t* mutex) {
-#if defined(NDEBUG) || !defined(PTHREAD_MUTEX_ERRORCHECK)
+#if defined(__wasi__) || defined(NDEBUG) || !defined(PTHREAD_MUTEX_ERRORCHECK)
   return pthread_mutex_init(mutex, NULL);
 #else
   pthread_mutexattr_t attr;