emnapi 0.31.0 → 0.33.0

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();
@@ -1250,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;
@@ -2180,7 +2390,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 +2403,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 +3050,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 +3064,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);
@@ -4459,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: [
@@ -4492,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
+                    }
                 }
             });
         }
@@ -4760,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/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.33.0",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "devDependencies": {

package/src/async_cleanup_hook.c

@@ -0,0 +1,126 @@
+#include "emnapi_internal.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_internal.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