emnapi 0.31.0 → 0.32.2

package/CMakeLists.txt

@@ -26,7 +26,19 @@ set(UV_SRC
   "${CMAKE_CURRENT_SOURCE_DIR}/src/uv/unix/core.c"
 )
 
-set(EMNAPI_SRC "${CMAKE_CURRENT_SOURCE_DIR}/src/emnapi.c")
+set(ENAPI_BASIC_SRC
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/js_native_api.c"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/node_api.c"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/emnapi.c"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/async_cleanup_hook.c"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/async_context.c"
+)
+set(EMNAPI_THREADS_SRC
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/async_work.c"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/threadsafe_function.c"
+)
+set(EMNAPI_SRC ${ENAPI_BASIC_SRC} ${EMNAPI_THREADS_SRC})
+
 set(EMNAPI_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
 set(EMNAPI_JS_LIB "${CMAKE_CURRENT_SOURCE_DIR}/dist/library_napi.js")
@@ -37,6 +49,7 @@ else()
   set(EMNAPI_MT_CFLAGS "-pthread")
 endif()
 
+set(EMNAPI_BASIC_TARGET_NAME "emnapi-basic")
 set(EMNAPI_TARGET_NAME "emnapi")
 set(EMNAPI_MT_TARGET_NAME "emnapi-mt")
 set(DLMALLOC_TARGET_NAME "dlmalloc")
@@ -82,6 +95,12 @@ if(IS_EMSCRIPTEN)
   target_link_options(${EMNAPI_TARGET_NAME} INTERFACE "--js-library=${EMNAPI_JS_LIB}")
 endif()
 
+add_library(${EMNAPI_BASIC_TARGET_NAME} STATIC ${ENAPI_BASIC_SRC})
+target_include_directories(${EMNAPI_BASIC_TARGET_NAME} PUBLIC ${EMNAPI_INCLUDE})
+if(IS_EMSCRIPTEN)
+  target_link_options(${EMNAPI_BASIC_TARGET_NAME} INTERFACE "--js-library=${EMNAPI_JS_LIB}")
+endif()
+
 if(IS_EMSCRIPTEN OR (CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi-threads"))
   set(EMNAPI_BUILD_MT ON)
 else()
@@ -118,6 +137,7 @@ endif()
 # endif()
 if(LIB_ARCH)
   install(TARGETS ${EMNAPI_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
+  install(TARGETS ${EMNAPI_BASIC_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
   if(EMNAPI_BUILD_MT)
     install(TARGETS ${EMNAPI_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
   endif()
@@ -150,6 +170,7 @@ install(FILES
 if(EMNAPI_INSTALL_SRC)
   install(FILES
       ${EMNAPI_SRC}
+      "${CMAKE_CURRENT_SOURCE_DIR}/src/emnapi_common.h"
     DESTINATION "src/${PROJECT_NAME}")
   install(DIRECTORY
     ${CMAKE_CURRENT_SOURCE_DIR}/src/uv

package/README.md

@@ -348,12 +348,13 @@ fetch('./hello.wasm').then(res => res.arrayBuffer()).then(wasmBuffer => {
     napi: napiModule.imports.napi,
     emnapi: napiModule.imports.emnapi
   })
-}).then(({ instance }) => {
-  const binding = napiModule.init(
+}).then(({ instance, module }) => {
+  const binding = napiModule.init({
     instance, // WebAssembly.Instance
-    instance.exports.memory, // WebAssembly.Memory
-    instance.exports.__indirect_function_table // WebAssembly.Table
-  )
+    module, // WebAssembly.Module
+    memory: instance.exports.memory, // WebAssembly.Memory
+    table: instance.exports.__indirect_function_table // WebAssembly.Table
+  })
   // binding === napiModule.exports
 })
 </script>
@@ -383,13 +384,14 @@ WebAssembly.instantiate(require('fs').readFileSync('./hello.wasm'), {
   // clang
   napi: napiModule.imports.napi,
   emnapi: napiModule.imports.emnapi
-}).then(({ instance }) => {
+}).then(({ instance, module }) => {
   wasi.initialize(instance)
-  const binding = napiModule.init(
+  const binding = napiModule.init({
     instance,
-    instance.exports.memory,
-    instance.exports.__indirect_function_table
-  )
+    module,
+    memory: instance.exports.memory,
+    table: instance.exports.__indirect_function_table
+  })
   // binding === napiModule.exports
 })
 ```
@@ -408,7 +410,7 @@ const napiModule = createNapiModule({
 })
 
 const fs = createFsFromVolume(Volume.from({ /* ... */ }))
-const wasi = WASI.createSync({ fs, /* ... */ })
+const wasi = new WASI({ fs, /* ... */ })
 
 WebAssembly.instantiate(wasmBuffer, {
   wasi_snapshot_preview1: wasi.wasiImport,
@@ -421,13 +423,14 @@ WebAssembly.instantiate(wasmBuffer, {
   // clang
   napi: napiModule.imports.napi,
   emnapi: napiModule.imports.emnapi
-}).then(({ instance }) => {
+}).then(({ instance, module }) => {
   wasi.initialize(instance)
-  const binding = napiModule.init(
+  const binding = napiModule.init({
     instance,
-    instance.exports.memory,
-    instance.exports.__indirect_function_table
-  )
+    module,
+    memory: instance.exports.memory,
+    table: instance.exports.__indirect_function_table
+  })
   // binding === napiModule.exports
 })
 ```

package/dist/library_napi.js

@@ -1,5 +1,205 @@
 {{{ ((DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.indexOf("$emnapiInit") === -1 ? DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.push("$emnapiInit") : undefined), "") }}}
 {{{ ((EXPORTED_RUNTIME_METHODS.indexOf("emnapiInit") === -1 ? EXPORTED_RUNTIME_METHODS.push("emnapiInit") : undefined), "") }}}
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function emnapiCreateIdGenerator() {
+    var obj = {
+        nextId: 1,
+        list: [],
+        generate: function () {
+            var id;
+            if (obj.list.length) {
+                id = obj.list.shift();
+            }
+            else {
+                id = obj.nextId;
+                obj.nextId++;
+            }
+            return id;
+        },
+        reuse: function (id) {
+            obj.list.push(id);
+        }
+    };
+    return obj;
+}
+var emnapiAsyncWork = {
+    idGen: {},
+    values: [undefined],
+    queued: new Set(),
+    pending: [],
+    init: function () {
+        emnapiAsyncWork.idGen = emnapiCreateIdGenerator();
+        emnapiAsyncWork.values = [undefined];
+        emnapiAsyncWork.queued = new Set();
+        emnapiAsyncWork.pending = [];
+    },
+    create: function (env, resource, resourceName, execute, complete, data) {
+        var asyncId = 0;
+        var triggerAsyncId = 0;
+        if (emnapiNodeBinding) {
+            var asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resourceName, -1);
+            asyncId = asyncContext.asyncId;
+            triggerAsyncId = asyncContext.triggerAsyncId;
+        }
+        var id = emnapiAsyncWork.idGen.generate();
+        emnapiAsyncWork.values[id] = {
+            env: env,
+            id: id,
+            resource: resource,
+            resourceName: resourceName,
+            asyncId: asyncId,
+            triggerAsyncId: triggerAsyncId,
+            status: 0,
+            execute: execute,
+            complete: complete,
+            data: data
+        };
+        return id;
+    },
+    callComplete: function (work, status) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        var complete = work.complete;
+        var env = work.env;
+        var data = work.data;
+        var callback = function () {
+            var envObject = emnapiCtx.envStore.get(env);
+            var scope = emnapiCtx.openScope(envObject);
+            try {
+                envObject.callIntoModule(function () {
+                    {{{ makeDynCall('vpip', 'complete') }}}(env, status, data);
+                });
+            }
+            finally {
+                emnapiCtx.closeScope(envObject, scope);
+            }
+        };
+        if (emnapiNodeBinding) {
+            emnapiNodeBinding.node.makeCallback(work.resource, callback, [], {
+                asyncId: work.asyncId,
+                triggerAsyncId: work.triggerAsyncId
+            });
+        }
+        else {
+            callback();
+        }
+    },
+    queue: function (id) {
+        var work = emnapiAsyncWork.values[id];
+        if (!work)
+            return;
+        if (work.status === 0) {
+            work.status = 1;
+            if (emnapiAsyncWork.queued.size >= 4) {
+                emnapiAsyncWork.pending.push(id);
+                return;
+            }
+            emnapiAsyncWork.queued.add(id);
+            var env_1 = work.env;
+            var data_1 = work.data;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            var execute = work.execute;
+            work.status = 2;
+            emnapiCtx.feature.setImmediate(function () {
+                {{{ makeDynCall('vpp', 'execute') }}}(env_1, data_1);
+                emnapiAsyncWork.queued.delete(id);
+                work.status = 3;
+                emnapiAsyncWork.callComplete(work, 0 /* napi_status.napi_ok */);
+                if (emnapiAsyncWork.pending.length > 0) {
+                    var nextWorkId = emnapiAsyncWork.pending.shift();
+                    emnapiAsyncWork.values[nextWorkId].status = 0;
+                    emnapiAsyncWork.queue(nextWorkId);
+                }
+            });
+        }
+    },
+    cancel: function (id) {
+        var index = emnapiAsyncWork.pending.indexOf(id);
+        if (index !== -1) {
+            var work = emnapiAsyncWork.values[id];
+            if (work && (work.status === 1)) {
+                work.status = 4;
+                emnapiAsyncWork.pending.splice(index, 1);
+                emnapiAsyncWork.callComplete(work, 11 /* napi_status.napi_cancelled */);
+                return 0 /* napi_status.napi_ok */;
+            }
+            else {
+                return 9 /* napi_status.napi_generic_failure */;
+            }
+        }
+        return 9 /* napi_status.napi_generic_failure */;
+    },
+    remove: function (id) {
+        var work = emnapiAsyncWork.values[id];
+        if (!work)
+            return;
+        if (emnapiNodeBinding) {
+            emnapiNodeBinding.node.emitAsyncDestroy({
+                asyncId: work.asyncId,
+                triggerAsyncId: work.triggerAsyncId
+            });
+        }
+        emnapiAsyncWork.values[id] = undefined;
+        emnapiAsyncWork.idGen.reuse(id);
+    }
+};
+function _napi_create_async_work(env, resource, resource_name, execute, complete, data, result) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (execute == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    if (result == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var resourceObject;
+    if (resource) {
+        resourceObject = Object(emnapiCtx.handleStore.get(resource).value);
+    }
+    else {
+        resourceObject = {};
+    }
+    if (resource_name == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var resourceName = String(emnapiCtx.handleStore.get(resource_name).value);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var id = emnapiAsyncWork.create(env, resourceObject, resourceName, execute, complete, data);
+    {{{ makeSetValue('result', 0, 'id', '*') }}};
+    return envObject.clearLastError();
+}
+function _napi_delete_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    emnapiAsyncWork.remove(work);
+    return envObject.clearLastError();
+}
+function _napi_queue_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    emnapiAsyncWork.queue(work);
+    return envObject.clearLastError();
+}
+function _napi_cancel_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var status = emnapiAsyncWork.cancel(work);
+    if (status === 0 /* napi_status.napi_ok */)
+        return envObject.clearLastError();
+    return envObject.setLastError(status);
+}
+emnapiImplementHelper('$emnapiCreateIdGenerator', undefined, emnapiCreateIdGenerator, []);
+emnapiDefineVar('$emnapiAsyncWork', emnapiAsyncWork, ['$emnapiCreateIdGenerator'], 'emnapiAsyncWork.init();');
+emnapiImplement('napi_create_async_work', 'ippppppp', _napi_create_async_work, ['$emnapiAsyncWork']);
+emnapiImplement('napi_delete_async_work', 'ipp', _napi_delete_async_work, ['$emnapiAsyncWork']);
+emnapiImplement('napi_queue_async_work', 'ipp', _napi_queue_async_work, ['$emnapiAsyncWork']);
+emnapiImplement('napi_cancel_async_work', 'ipp', _napi_cancel_async_work, ['$emnapiAsyncWork']);
 function _emnapi_create_memory_view(env, typedarray_type, external_data, byte_length, finalize_cb, finalize_hint, result
 // @ts-expect-error
 ) {
@@ -826,10 +1026,18 @@ function emnapiCreateFunction(envObject, utf8name, length, cb, data) {
     }
 #if DYNAMIC_EXECUTION
     if (emnapiCtx.feature.supportNewFunction) {
-        f = (new Function('_', 'return function ' + functionName + '(){' +
-            '"use strict";' +
-            'return _.apply(this,arguments);' +
-            '};'))(makeFunction());
+        var _ = makeFunction();
+        try {
+            f = (new Function('_', 'return function ' + functionName + '(){' +
+                '"use strict";' +
+                'return _.apply(this,arguments);' +
+                '};'))(_);
+        }
+        catch (_err) {
+            f = makeFunction();
+            if (emnapiCtx.feature.canSetFunctionName)
+                Object.defineProperty(f, 'name', { value: functionName });
+        }
     }
     else {
         f = makeFunction();
@@ -2180,7 +2388,7 @@ function napi_define_properties(env, object, property_count, properties
             var value_2 = {{{ makeGetValue("propPtr", POINTER_SIZE * 5, "*") }}};
             attributes = {{{ makeGetValue("propPtr", POINTER_SIZE * 6, POINTER_WASM_TYPE) }}};
             {{{ from64("attributes") }}};
-            var data_1 = {{{ makeGetValue("propPtr", POINTER_SIZE * 7, "*") }}};
+            var data_2 = {{{ makeGetValue("propPtr", POINTER_SIZE * 7, "*") }}};
             if (utf8Name_1) {
                 propertyName_1 = UTF8ToString(utf8Name_1);
             }
@@ -2193,7 +2401,7 @@ function napi_define_properties(env, object, property_count, properties
                     return envObject_32.setLastError(4 /* napi_status.napi_name_expected */);
                 }
             }
-            emnapiDefineProperty(envObject_32, maybeObject_1, propertyName_1, method_1, getter_1, setter_1, value_2, attributes, data_1);
+            emnapiDefineProperty(envObject_32, maybeObject_1, propertyName_1, method_1, getter_1, setter_1, value_2, attributes, data_2);
         }
         return 0 /* napi_status.napi_ok */;
     }
@@ -2840,7 +3048,7 @@ function napi_define_class(env, utf8name, length, constructor, callback_data, pr
             var value_3 = {{{ makeGetValue("propPtr", POINTER_SIZE * 5, "*") }}};
             attributes = {{{ makeGetValue("propPtr", POINTER_SIZE * 6, POINTER_WASM_TYPE) }}};
             {{{ from64("attributes") }}};
-            var data_2 = {{{ makeGetValue("propPtr", POINTER_SIZE * 7, "*") }}};
+            var data_3 = {{{ makeGetValue("propPtr", POINTER_SIZE * 7, "*") }}};
             if (utf8Name_2) {
                 propertyName_2 = UTF8ToString(utf8Name_2);
             }
@@ -2854,10 +3062,10 @@ function napi_define_class(env, utf8name, length, constructor, callback_data, pr
                 }
             }
             if ((attributes & 1024 /* napi_property_attributes.napi_static */) !== 0) {
-                emnapiDefineProperty(envObject_43, F_1, propertyName_2, method_2, getter_2, setter_2, value_3, attributes, data_2);
+                emnapiDefineProperty(envObject_43, F_1, propertyName_2, method_2, getter_2, setter_2, value_3, attributes, data_3);
                 continue;
             }
-            emnapiDefineProperty(envObject_43, F_1.prototype, propertyName_2, method_2, getter_2, setter_2, value_3, attributes, data_2);
+            emnapiDefineProperty(envObject_43, F_1.prototype, propertyName_2, method_2, getter_2, setter_2, value_3, attributes, data_3);
         }
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         var valueHandle_2 = emnapiCtx.addToCurrentScope(F_1);

package/index.js

@@ -7,7 +7,13 @@ const include = path.join(__dirname, 'include')
 const includeDir = path.relative(process.cwd(), include)
 const jsLibrary = path.join(__dirname, './dist/library_napi.js')
 const sources = [
+  path.join(__dirname, './src/js_native_api.c'),
+  path.join(__dirname, './src/node_api.c'),
   path.join(__dirname, './src/emnapi.c'),
+  path.join(__dirname, './src/async_cleanup_hook.c'),
+  path.join(__dirname, './src/async_context.c'),
+  path.join(__dirname, './src/async_work.c'),
+  path.join(__dirname, './src/threadsafe_function.c'),
   path.join(__dirname, './src/uv/uv-common.c'),
   path.join(__dirname, './src/uv/threadpool.c'),
   path.join(__dirname, './src/uv/unix/loop.c'),

package/lib/wasm32-emscripten.txt

@@ -1,5 +1,5 @@
-emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 3.1.29 (43074846f216abad2a1c35b5a631f2a9481d9e07)
-clang version 16.0.0 (https://github.com/llvm/llvm-project 947d529e4194e0567cfbbea99127066f76c87269)
+emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 3.1.32 (eab98adf462c39f3c31d348331c4830bcaa36949)
+clang version 17.0.0 (https://github.com/llvm/llvm-project df82394e7a2d06506718cafa347bf7827c79fc4f)
 Target: wasm32-unknown-emscripten
 Thread model: posix
 InstalledDir: /home/runner/work/emnapi/emnapi/emsdk-cache/emsdk-main/upstream/bin

package/package.json

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

package/src/async_cleanup_hook.c

@@ -0,0 +1,126 @@
+#include "emnapi_common.h"
+#include "node_api.h"
+
+EXTERN_C_START
+
+typedef void (*async_cleanup_hook)(void* arg, void(*)(void*), void*);
+
+struct async_cleanup_hook_info {
+  napi_env env;
+  async_cleanup_hook fun;
+  void* arg;
+  bool started;
+};
+
+struct napi_async_cleanup_hook_handle__ {
+  struct async_cleanup_hook_info* handle_;
+  napi_env env_;
+  napi_async_cleanup_hook user_hook_;
+  void* user_data_;
+  void (*done_cb_)(void*);
+  void* done_data_;
+};
+
+static void _emnapi_ach_handle_hook(void* data, void (*done_cb)(void*), void* done_data) {
+  napi_async_cleanup_hook_handle handle =
+      (napi_async_cleanup_hook_handle) (data);
+  handle->done_cb_ = done_cb;
+  handle->done_data_ = done_data;
+  handle->user_hook_(handle, handle->user_data_);
+}
+
+static void _emnapi_finish_async_cleanup_hook(void* arg) {
+  // struct async_cleanup_hook_info* info = (struct async_cleanup_hook_info*) (arg);
+  EMNAPI_KEEPALIVE_POP();
+  _emnapi_ctx_decrease_waiting_request_counter();
+}
+
+static void _emnapi_run_async_cleanup_hook(void* arg) {
+  struct async_cleanup_hook_info* info = (struct async_cleanup_hook_info*) (arg);
+  EMNAPI_KEEPALIVE_PUSH();
+  _emnapi_ctx_increase_waiting_request_counter();
+  info->started = true;
+  info->fun(info->arg, _emnapi_finish_async_cleanup_hook, info);
+}
+
+static struct async_cleanup_hook_info*
+_emnapi_add_async_environment_cleanup_hook(napi_env env,
+                                           async_cleanup_hook fun,
+                                           void* arg) {
+  struct async_cleanup_hook_info* info =
+    (struct async_cleanup_hook_info*) malloc(sizeof(struct async_cleanup_hook_info));
+  info->env = env;
+  info->fun = fun;
+  info->arg = arg;
+  info->started = false;
+
+  EMNAPI_ASSERT_CALL(napi_add_env_cleanup_hook(env, _emnapi_run_async_cleanup_hook, info));
+
+  return info;
+}
+
+static void _emnapi_remove_async_environment_cleanup_hook(
+    struct async_cleanup_hook_info* info) {
+  if (info->started) return;
+  EMNAPI_ASSERT_CALL(napi_remove_env_cleanup_hook(info->env, _emnapi_run_async_cleanup_hook, info));
+}
+
+static napi_async_cleanup_hook_handle
+_emnapi_ach_handle_create(napi_env env,
+                          napi_async_cleanup_hook user_hook,
+                          void* user_data) {
+  napi_async_cleanup_hook_handle handle =
+    (napi_async_cleanup_hook_handle) calloc(1, sizeof(struct napi_async_cleanup_hook_handle__));
+  handle->env_ = env;
+  handle->user_hook_ = user_hook;
+  handle->user_data_ = user_data;
+  handle->handle_ = _emnapi_add_async_environment_cleanup_hook(env, _emnapi_ach_handle_hook, handle);
+  _emnapi_env_ref(env);
+
+  return handle;
+}
+
+EMNAPI_INTERNAL_EXTERN void _emnapi_set_immediate(void (*callback)(void*), void* data);
+
+static void _emnapi_ach_handle_env_unref(void* arg) {
+  napi_env env = (napi_env) arg;
+  _emnapi_env_unref(env);
+}
+
+static void
+_emnapi_ach_handle_delete(napi_async_cleanup_hook_handle handle) {
+  _emnapi_remove_async_environment_cleanup_hook(handle->handle_);
+  if (handle->done_cb_ != NULL) handle->done_cb_(handle->done_data_);
+
+  _emnapi_set_immediate(_emnapi_ach_handle_env_unref, handle->env_);
+
+  free(handle->handle_);
+  free(handle);
+}
+
+napi_status
+napi_add_async_cleanup_hook(napi_env env,
+                            napi_async_cleanup_hook hook,
+                            void* arg,
+                            napi_async_cleanup_hook_handle* remove_handle) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, hook);
+
+  napi_async_cleanup_hook_handle handle =
+      _emnapi_ach_handle_create(env, hook, arg);
+
+  if (remove_handle != NULL) *remove_handle = handle;
+
+  return napi_clear_last_error(env);
+}
+
+napi_status
+napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle) {
+  if (remove_handle == NULL) return napi_invalid_arg;
+
+  _emnapi_ach_handle_delete(remove_handle);
+
+  return napi_ok;
+}
+
+EXTERN_C_END

package/src/async_context.c

@@ -0,0 +1,53 @@
+#include <node_api.h>
+#include "emnapi_common.h"
+
+EXTERN_C_START
+
+struct napi_async_context__ {
+  int32_t low;
+  int32_t high;
+};
+
+EMNAPI_INTERNAL_EXTERN napi_status
+_emnapi_async_init_js(napi_value async_resource,
+                      napi_value async_resource_name,
+                      napi_async_context result);
+EMNAPI_INTERNAL_EXTERN napi_status
+_emnapi_async_destroy_js(napi_async_context async_context);
+
+napi_status
+napi_async_init(napi_env env,
+                napi_value async_resource,
+                napi_value async_resource_name,
+                napi_async_context* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, async_resource_name);
+  CHECK_ARG(env, result);
+
+  napi_async_context ret = (napi_async_context) malloc(sizeof(struct napi_async_context__));
+
+  napi_status status = _emnapi_async_init_js(async_resource, async_resource_name, ret);
+  if (status != napi_ok) {
+    free(ret);
+    return napi_set_last_error(env, status, 0, NULL);
+  }
+
+  *result = ret;
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_async_destroy(napi_env env,
+                               napi_async_context async_context) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, async_context);
+
+  napi_status status = _emnapi_async_destroy_js(async_context);
+  if (status != napi_ok) {
+    return napi_set_last_error(env, status, 0, NULL);
+  }
+  free(async_context);
+
+  return napi_clear_last_error(env);
+}
+
+EXTERN_C_END