emnapi 1.10.0 → 1.11.0

package/dist/library_napi.js

@@ -53,11 +53,11 @@ function emnapiInit(options) {
     var scope = emnapiCtx.openScope(envObject);
     try {
         envObject.callIntoModule(function (_envObject) {
-            var exports$1 = emnapiModule.exports;
+            var exports = emnapiModule.exports;
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            var exportsHandle = scope.add(exports$1);
+            var exportsHandle = scope.add(exports);
             var napiValue = _napi_register_wasm_v1({{{ to64('_envObject.id') }}}, {{{ to64('exportsHandle.id') }}});
-            emnapiModule.exports = (!napiValue) ? exports$1 : emnapiCtx.handleStore.get(napiValue).value;
+            emnapiModule.exports = (!napiValue) ? exports : emnapiCtx.handleStore.get(napiValue).value;
         });
     }
     catch (err) {
@@ -299,7 +299,7 @@ function __emnapi_worker_unref(pid) {
  * @__postset
  * ```
  * PThread.unusedWorkers.forEach(emnapiAddSendListener);
- * PThread.runningWorkers.forEach(emnapiAddSendListener);
+ * Object.values(PThread.pthreads).forEach(emnapiAddSendListener);
  * (function () {
  *   var __original_getNewWorker = PThread.getNewWorker;
  *   PThread.getNewWorker = function () {
@@ -1085,6 +1085,73 @@ var emnapiExternalMemory = {
         return { address: address === 0 ? 0 : (address + view.byteOffset), ownership: ownership, runtimeAllocated: runtimeAllocated, view: view };
     }
 };
+/**
+ * Metadata layout in wasm shared memory (allocated with _malloc):
+ *   offset 0:              refcount     (int32, 4 bytes - for Atomics)
+ *   offset POINTER_SIZE:   external_data (pointer)
+ *   offset 2*POINTER_SIZE: byte_length   (size_t)
+ *   offset 3*POINTER_SIZE: finalize_cb   (pointer)
+ *   offset 4*POINTER_SIZE: finalize_data (pointer)
+ *   offset 5*POINTER_SIZE: finalize_hint (pointer)
+ *   Total: 6 * POINTER_SIZE bytes
+ */
+/**
+ * @__postset
+ * ```
+ * emnapiExternalSAB.init();
+ * ```
+ */
+var emnapiExternalSAB = {
+    registry: undefined,
+    handleTable: new WeakMap(),
+    init: function () {
+        emnapiExternalSAB.handleTable = new WeakMap();
+        emnapiExternalSAB.registry = typeof FinalizationRegistry === 'function'
+            ? new FinalizationRegistry(function (metaPtr) {
+                emnapiExternalSAB.release(metaPtr);
+            })
+            : undefined;
+    },
+    allocMeta: function (external_data, byte_length, finalize_cb, finalize_data, finalize_hint) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        var size = {{{ POINTER_SIZE }}} * 6;
+        // eslint-disable-next-line prefer-const
+        var metaPtr = _malloc({{{ to64('size') }}});
+        if (!metaPtr)
+            throw new Error('Out of memory');
+        {{{ from64('metaPtr') }}};
+        // refcount = 1
+        Atomics.store(new Int32Array(wasmMemory.buffer, metaPtr, 1), 0, 1);
+        {{{ makeSetValue('metaPtr', POINTER_SIZE, 'external_data', '*') }}};
+        {{{ makeSetValue('metaPtr', POINTER_SIZE * 2, 'byte_length', '*') }}};
+        {{{ makeSetValue('metaPtr', POINTER_SIZE * 3, 'finalize_cb', '*') }}};
+        {{{ makeSetValue('metaPtr', POINTER_SIZE * 4, 'finalize_data', '*') }}};
+        {{{ makeSetValue('metaPtr', POINTER_SIZE * 5, 'finalize_hint', '*') }}};
+        return metaPtr;
+    },
+    readMeta: function (metaPtr) {
+        var external_data = {{{ makeGetValue('metaPtr', POINTER_SIZE, '*') }}};
+        var byte_length = {{{ makeGetValue('metaPtr', POINTER_SIZE * 2, '*') }}};
+        var finalize_cb = {{{ makeGetValue('metaPtr', POINTER_SIZE * 3, '*') }}};
+        var finalize_data = {{{ makeGetValue('metaPtr', POINTER_SIZE * 4, '*') }}};
+        var finalize_hint = {{{ makeGetValue('metaPtr', POINTER_SIZE * 5, '*') }}};
+        return { external_data: external_data, byte_length: byte_length, finalize_cb: finalize_cb, finalize_data: finalize_data, finalize_hint: finalize_hint };
+    },
+    release: function (metaPtr) {
+        var oldRefcount = Atomics.sub(new Int32Array(wasmMemory.buffer, metaPtr, 1), 0, 1);
+        if (oldRefcount === 1) {
+            // refcount reached 0, we are the last holder
+            var info = emnapiExternalSAB.readMeta(metaPtr);
+            var finalize_cb = info.finalize_cb;
+            if (finalize_cb) {
+                var finalize_data = info.finalize_data;
+                var finalize_hint = info.finalize_hint;
+                {{{ makeDynCall('vpp', 'finalize_cb') }}}(finalize_data, finalize_hint);
+            }
+            _free({{{ to64('metaPtr') }}});
+        }
+    }
+};
 /**
  * @__sig ippp
  */
@@ -2854,7 +2921,107 @@ function _emnapi_get_runtime_version(env, version) {
     {{{ makeSetValue('version', 8, 'versions[2]', 'u32') }}};
     return envObject.clearLastError();
 }
-// emnapiImplementHelper('$emnapiSyncMemory', undefined, emnapiSyncMemory, ['$emnapiExternalMemory'], 'syncMemory')
+/**
+ * Get the handle for an external SharedArrayBuffer.
+ * Must be called on the emnapi main thread.
+ * @__sig ippp
+ */
+function _emnapi_get_external_sharedarraybuffer_handle(env, sharedarraybuffer, handle) {
+    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 (!sharedarraybuffer)
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+        if (!handle)
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+        {{{ from64('handle') }}};
+        var jsValue = emnapiCtx.handleStore.get(sharedarraybuffer).value;
+        if (!emnapiExternalMemory.isSharedArrayBuffer(jsValue)) {
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+        }
+        var metaPtr = emnapiExternalSAB.handleTable.get(jsValue);
+        if (metaPtr === undefined) {
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+        }
+        {{{ makeSetValue('handle', 0, 'metaPtr', '*') }}};
+        return envObject.getReturnStatus();
+    }
+    catch (err) {
+        envObject.tryCatch.setError(err);
+        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+    }
+}
+/**
+ * Acquire a reference to an external SharedArrayBuffer.
+ * Can be called on any thread.
+ * @__sig vp
+ */
+function _emnapi_acquire_external_sharedarraybuffer(handle) {
+    {{{ from64('handle') }}};
+    Atomics.add(new Int32Array(wasmMemory.buffer, handle, 1), 0, 1);
+}
+/**
+ * Release a reference to an external SharedArrayBuffer.
+ * Can be called on any thread.
+ * @__sig vp
+ */
+function _emnapi_release_external_sharedarraybuffer(handle) {
+    {{{ from64('handle') }}};
+    emnapiExternalSAB.release(handle);
+}
+/**
+ * Acquire a reference to an external SharedArrayBuffer on the current thread.
+ * Can be called on any thread. Increments refcount and registers in
+ * the current thread's FinalizationRegistry.
+ * Exposed as Module.emnapiAcquireExternalSharedArrayBuffer (emscripten) or
+ * napiModule.emnapi.acquireExternalSharedArrayBuffer (core).
+ */
+function emnapiAcquireExternalSharedArrayBuffer(handle, sab) {
+    if (sab != null && !emnapiExternalMemory.isSharedArrayBuffer(sab)) {
+        throw new TypeError('Expected a SharedArrayBuffer');
+    }
+    if (!emnapiExternalSAB.registry) {
+        throw new Error('FinalizationRegistry is not supported in this environment');
+    }
+    {{{ from64('handle') }}};
+    var meta = emnapiExternalSAB.readMeta(handle);
+    // eslint-disable-next-line prefer-const
+    var external_data = meta.external_data;
+    {{{ from64('external_data') }}};
+    if (sab == null) {
+        sab = new SharedArrayBuffer(meta.byte_length);
+        new Uint8Array(sab).set(new Uint8Array(wasmMemory.buffer, external_data, meta.byte_length));
+    }
+    else {
+        if (emnapiExternalSAB.handleTable.has(sab)) {
+            return sab;
+        }
+    }
+    // Increment refcount atomically
+    Atomics.add(new Int32Array(wasmMemory.buffer, handle, 1), 0, 1);
+    // Register in emnapiExternalMemory.table for emnapi_sync_memory support
+    if (!emnapiExternalMemory.table.has(sab)) {
+        if (external_data) {
+            emnapiExternalMemory.table.set(sab, {
+                address: external_data,
+                ownership: 1 /* ReferenceOwnership.kUserland */,
+                runtimeAllocated: 0
+            });
+        }
+    }
+    // Register in handleTable and FinalizationRegistry for this thread
+    emnapiExternalSAB.handleTable.set(sab, handle);
+    emnapiExternalSAB.registry.register(sab, handle);
+    return sab;
+}
 // emnapiImplementHelper('$emnapiGetMemoryAddress', undefined, emnapiGetMemoryAddress, ['$emnapiExternalMemory'], 'getMemoryAddress')
 /**
  * @__sig ipp
@@ -3101,6 +3268,64 @@ function _napi_create_external_arraybuffer(env, external_data, byte_length, fina
         return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
+/**
+ * @__sig ipppppp
+ */
+function _node_api_create_external_sharedarraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, 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('byte_length') }}};
+        {{{ from64('external_data') }}};
+        {{{ from64('result') }}};
+        byte_length = byte_length >>> 0;
+        if (!external_data) {
+            byte_length = 0;
+        }
+        if ((external_data + byte_length) > wasmMemory.buffer.byteLength) {
+            throw new RangeError('Memory out of range');
+        }
+        if (!emnapiExternalSAB.registry && finalize_cb) {
+            throw emnapiCtx.createNotSupportWeakRefError('node_api_create_external_sharedarraybuffer', 'Parameter "finalize_cb" must be 0(NULL)');
+        }
+        var sharedArrayBuffer = new SharedArrayBuffer(byte_length);
+        if (byte_length !== 0) {
+            var u8arr = new Uint8Array(sharedArrayBuffer);
+            u8arr.set(new Uint8Array(wasmMemory.buffer).subarray(external_data, external_data + byte_length));
+            emnapiExternalMemory.table.set(sharedArrayBuffer, {
+                address: external_data,
+                ownership: 1 /* ReferenceOwnership.kUserland */,
+                runtimeAllocated: 0
+            });
+        }
+        value = emnapiCtx.addToCurrentScope(sharedArrayBuffer).id;
+        if (finalize_cb) {
+            {{{ from64('finalize_cb') }}};
+            {{{ from64('finalize_hint') }}};
+            var metaPtr = emnapiExternalSAB.allocMeta(external_data, byte_length, finalize_cb, external_data, finalize_hint);
+            emnapiExternalSAB.handleTable.set(sharedArrayBuffer, metaPtr);
+            emnapiExternalSAB.registry.register(sharedArrayBuffer, metaPtr);
+        }
+        {{{ makeSetValue('result', 0, 'value', '*') }}};
+        return envObject.getReturnStatus();
+    }
+    catch (err) {
+        envObject.tryCatch.setError(err);
+        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+    }
+}
 /**
  * @__sig ipp
  */
@@ -3218,9 +3443,6 @@ function _napi_create_typedarray(env, type, length, arraybuffer, byte_offset, re
         if (!result)
             return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
         var handle = emnapiCtx.handleStore.get(arraybuffer);
-        if (!handle.isArrayBuffer()) {
-            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-        }
         var buffer = handle.value;
         {{{ from64('byte_offset') }}};
         {{{ from64('length') }}};
@@ -3260,36 +3482,41 @@ function _napi_create_typedarray(env, type, length, arraybuffer, byte_offset, re
             {{{ makeSetValue('result', 0, 'value', '*') }}};
             return envObject.getReturnStatus();
         };
-        switch (type) {
-            case 0 /* napi_typedarray_type.napi_int8_array */:
-                return createTypedArray(envObject, Int8Array, 1, buffer, byte_offset, length);
-            case 1 /* napi_typedarray_type.napi_uint8_array */:
-                return createTypedArray(envObject, Uint8Array, 1, buffer, byte_offset, length);
-            case 2 /* napi_typedarray_type.napi_uint8_clamped_array */:
-                return createTypedArray(envObject, Uint8ClampedArray, 1, buffer, byte_offset, length);
-            case 3 /* napi_typedarray_type.napi_int16_array */:
-                return createTypedArray(envObject, Int16Array, 2, buffer, byte_offset, length);
-            case 4 /* napi_typedarray_type.napi_uint16_array */:
-                return createTypedArray(envObject, Uint16Array, 2, buffer, byte_offset, length);
-            case 5 /* napi_typedarray_type.napi_int32_array */:
-                return createTypedArray(envObject, Int32Array, 4, buffer, byte_offset, length);
-            case 6 /* napi_typedarray_type.napi_uint32_array */:
-                return createTypedArray(envObject, Uint32Array, 4, buffer, byte_offset, length);
-            case 7 /* napi_typedarray_type.napi_float32_array */:
-                return createTypedArray(envObject, Float32Array, 4, buffer, byte_offset, length);
-            case 8 /* napi_typedarray_type.napi_float64_array */:
-                return createTypedArray(envObject, Float64Array, 8, buffer, byte_offset, length);
-            case 9 /* napi_typedarray_type.napi_bigint64_array */:
-                return createTypedArray(envObject, BigInt64Array, 8, buffer, byte_offset, length);
-            case 10 /* napi_typedarray_type.napi_biguint64_array */:
-                return createTypedArray(envObject, BigUint64Array, 8, buffer, byte_offset, length);
-            case 11 /* napi_typedarray_type.napi_float16_array */:
-                if (typeof Float16Array !== 'function') {
+        if (buffer instanceof ArrayBuffer || emnapiExternalMemory.isSharedArrayBuffer(buffer)) {
+            switch (type) {
+                case 0 /* napi_typedarray_type.napi_int8_array */:
+                    return createTypedArray(envObject, Int8Array, 1, buffer, byte_offset, length);
+                case 1 /* napi_typedarray_type.napi_uint8_array */:
+                    return createTypedArray(envObject, Uint8Array, 1, buffer, byte_offset, length);
+                case 2 /* napi_typedarray_type.napi_uint8_clamped_array */:
+                    return createTypedArray(envObject, Uint8ClampedArray, 1, buffer, byte_offset, length);
+                case 3 /* napi_typedarray_type.napi_int16_array */:
+                    return createTypedArray(envObject, Int16Array, 2, buffer, byte_offset, length);
+                case 4 /* napi_typedarray_type.napi_uint16_array */:
+                    return createTypedArray(envObject, Uint16Array, 2, buffer, byte_offset, length);
+                case 5 /* napi_typedarray_type.napi_int32_array */:
+                    return createTypedArray(envObject, Int32Array, 4, buffer, byte_offset, length);
+                case 6 /* napi_typedarray_type.napi_uint32_array */:
+                    return createTypedArray(envObject, Uint32Array, 4, buffer, byte_offset, length);
+                case 7 /* napi_typedarray_type.napi_float32_array */:
+                    return createTypedArray(envObject, Float32Array, 4, buffer, byte_offset, length);
+                case 8 /* napi_typedarray_type.napi_float64_array */:
+                    return createTypedArray(envObject, Float64Array, 8, buffer, byte_offset, length);
+                case 9 /* napi_typedarray_type.napi_bigint64_array */:
+                    return createTypedArray(envObject, BigInt64Array, 8, buffer, byte_offset, length);
+                case 10 /* napi_typedarray_type.napi_biguint64_array */:
+                    return createTypedArray(envObject, BigUint64Array, 8, buffer, byte_offset, length);
+                case 11 /* napi_typedarray_type.napi_float16_array */:
+                    if (typeof Float16Array !== 'function') {
+                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+                    }
+                    return createTypedArray(envObject, Float16Array, 2, buffer, byte_offset, length);
+                default:
                     return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-                }
-                return createTypedArray(envObject, Float16Array, 2, buffer, byte_offset, length);
-            default:
-                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+            }
+        }
+        else {
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
         }
     }
     catch (err) {
@@ -5609,7 +5836,7 @@ var emnapiTSFN = {
         emnapiTSFN.offset.mutex = emnapiTSFN.offset.mutex + 4;
         if (typeof PThread !== 'undefined') {
             PThread.unusedWorkers.forEach(emnapiTSFN.addListener);
-            PThread.runningWorkers.forEach(emnapiTSFN.addListener);
+            Object.values(PThread.pthreads).forEach(emnapiTSFN.addListener);
             var __original_getNewWorker_1 = PThread.getNewWorker;
             PThread.getNewWorker = function () {
                 var r = __original_getNewWorker_1.apply(this, arguments);
@@ -6999,14 +7226,18 @@ function _napi_get_version(env, result) {
     return envObject.clearLastError();
 }
 (typeof addToLibrary === "function" ? addToLibrary : (...args) => mergeInto(LibraryManager.library, ...args))({
-    $emnapiAddSendListener: emnapiAddSendListener,
-    $emnapiAddSendListener__deps: ["$PThread"],
-    $emnapiAddSendListener__postset: "PThread.unusedWorkers.forEach(emnapiAddSendListener);\nPThread.runningWorkers.forEach(emnapiAddSendListener);\n(function () {\n  var __original_getNewWorker = PThread.getNewWorker;\n  PThread.getNewWorker = function () {\n    var r = __original_getNewWorker.apply(this, arguments);\n    emnapiAddSendListener(r);\n    return r;\n  };\n})();",
-    $emnapiAsyncWorkPoolSize: "0",
     $emnapiCtx: "undefined",
     $emnapiExternalMemory: emnapiExternalMemory,
     $emnapiExternalMemory__deps: ["$emnapiCtx", "malloc", "free"],
     $emnapiExternalMemory__postset: "emnapiExternalMemory.init();",
+    $emnapiExternalSAB: emnapiExternalSAB,
+    $emnapiExternalSAB__postset: "emnapiExternalSAB.init();",
+    $emnapiAcquireExternalSharedArrayBuffer: emnapiAcquireExternalSharedArrayBuffer,
+    $emnapiAcquireExternalSharedArrayBuffer__deps: ["$emnapiExternalMemory", "$emnapiExternalSAB"],
+    $emnapiAddSendListener: emnapiAddSendListener,
+    $emnapiAddSendListener__deps: ["$PThread"],
+    $emnapiAddSendListener__postset: "PThread.unusedWorkers.forEach(emnapiAddSendListener);\nObject.values(PThread.pthreads).forEach(emnapiAddSendListener);\n(function () {\n  var __original_getNewWorker = PThread.getNewWorker;\n  PThread.getNewWorker = function () {\n    var r = __original_getNewWorker.apply(this, arguments);\n    emnapiAddSendListener(r);\n    return r;\n  };\n})();",
+    $emnapiAsyncWorkPoolSize: "0",
     $emnapiGetMemoryAddress: emnapiGetMemoryAddress,
     $emnapiGetMemoryAddress__deps: ["$emnapiExternalMemory"],
     $emnapiModule: emnapiModule,
@@ -7105,6 +7336,8 @@ function _napi_get_version(env, result) {
     _emnapi_worker_unref: __emnapi_worker_unref,
     _emnapi_worker_unref__deps: ["$PThread"],
     _emnapi_worker_unref__sig: "vp",
+    emnapi_acquire_external_sharedarraybuffer: _emnapi_acquire_external_sharedarraybuffer,
+    emnapi_acquire_external_sharedarraybuffer__sig: "vp",
     $emnapiGetHandle: emnapiGetHandle,
     $emnapiGetHandle__deps: ["$emnapiCtx", "$emnapiExternalMemory"],
     napi_add_finalizer: _napi_add_finalizer,
@@ -7113,6 +7346,9 @@ function _napi_get_version(env, result) {
     emnapi_create_memory_view: _emnapi_create_memory_view,
     emnapi_create_memory_view__deps: ["$emnapiCtx", "$emnapiExternalMemory", "napi_add_finalizer"],
     emnapi_create_memory_view__sig: "ipippppp",
+    emnapi_get_external_sharedarraybuffer_handle: _emnapi_get_external_sharedarraybuffer_handle,
+    emnapi_get_external_sharedarraybuffer_handle__deps: ["$emnapiCtx", "$emnapiExternalMemory", "$emnapiExternalSAB"],
+    emnapi_get_external_sharedarraybuffer_handle__sig: "ippp",
     emnapi_get_memory_address: _emnapi_get_memory_address,
     emnapi_get_memory_address__deps: ["$emnapiCtx", "$emnapiGetMemoryAddress"],
     emnapi_get_memory_address__sig: "ipppp",
@@ -7134,6 +7370,9 @@ function _napi_get_version(env, result) {
     emnapi_is_support_weakref: _emnapi_is_support_weakref,
     emnapi_is_support_weakref__deps: ["$emnapiCtx"],
     emnapi_is_support_weakref__sig: "i",
+    emnapi_release_external_sharedarraybuffer: _emnapi_release_external_sharedarraybuffer,
+    emnapi_release_external_sharedarraybuffer__deps: ["$emnapiExternalSAB"],
+    emnapi_release_external_sharedarraybuffer__sig: "vp",
     emnapi_sync_memory: _emnapi_sync_memory,
     emnapi_sync_memory__deps: ["$emnapiCtx", "$emnapiExternalMemory", "$emnapiSyncMemory"],
     emnapi_sync_memory__sig: "ipippp",
@@ -7566,6 +7805,9 @@ function _napi_get_version(env, result) {
     node_api_create_buffer_from_arraybuffer: _node_api_create_buffer_from_arraybuffer,
     node_api_create_buffer_from_arraybuffer__deps: ["$emnapiCtx", "$emnapiExternalMemory"],
     node_api_create_buffer_from_arraybuffer__sig: "ippppp",
+    node_api_create_external_sharedarraybuffer: _node_api_create_external_sharedarraybuffer,
+    node_api_create_external_sharedarraybuffer__deps: ["$emnapiCtx", "$emnapiExternalSAB", "$emnapiExternalMemory"],
+    node_api_create_external_sharedarraybuffer__sig: "ipppppp",
     node_api_create_external_string_latin1: _node_api_create_external_string_latin1,
     node_api_create_external_string_latin1__deps: ["$emnapiString", "napi_create_string_latin1"],
     node_api_create_external_string_latin1__sig: "ippppppp",

package/include/node/emnapi.h

@@ -6,7 +6,7 @@
 #include "emnapi_common.h"
 
 #define EMNAPI_MAJOR_VERSION 1
-#define EMNAPI_MINOR_VERSION 10
+#define EMNAPI_MINOR_VERSION 11
 #define EMNAPI_PATCH_VERSION 0
 
 typedef enum {
@@ -82,6 +82,31 @@ napi_status emnapi_get_memory_address(napi_env env,
                                       emnapi_ownership* ownership,
                                       bool* runtime_allocated);
 
+/**
+ * Get the handle for an external SharedArrayBuffer.
+ * This function must be called on the emnapi main thread.
+ */
+EMNAPI_EXTERN
+napi_status emnapi_get_external_sharedarraybuffer_handle(
+    napi_env env,
+    napi_value sharedarraybuffer,
+    void** handle);
+
+/**
+ * Acquire a reference to an external SharedArrayBuffer handle.
+ * This function may be called from any thread.
+ */
+EMNAPI_EXTERN
+void emnapi_acquire_external_sharedarraybuffer(void* handle);
+
+/**
+ * Release a reference to an external SharedArrayBuffer handle.
+ * When the refcount reaches zero, finalize_cb is invoked.
+ * This function may be called from any thread.
+ */
+EMNAPI_EXTERN
+void emnapi_release_external_sharedarraybuffer(void* handle);
+
 EXTERN_C_END
 
 #endif

package/include/node/js_native_api.h

@@ -443,6 +443,16 @@ napi_create_external_arraybuffer(napi_env env,
                                  node_api_basic_finalize finalize_cb,
                                  void* finalize_hint,
                                  napi_value* result);
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_CREATE_EXTERNAL_SHAREDARRAYBUFFER
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_create_external_sharedarraybuffer(napi_env env,
+                                           void* external_data,
+                                           size_t byte_length,
+                                           node_api_noenv_finalize finalize_cb,
+                                           void* finalize_hint,
+                                           napi_value* result);
+#endif  // NAPI_EXPERIMENTAL
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_arraybuffer_info(
     napi_env env, napi_value arraybuffer, void** data, size_t* byte_length);

package/include/node/js_native_api_types.h

@@ -188,6 +188,10 @@ typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env,
 #endif
 typedef node_api_nogc_finalize node_api_basic_finalize;
 
+// A finalizer that can be called from any thread and at any time.
+typedef void(NAPI_CDECL* node_api_noenv_finalize)(void* finalize_data,
+                                                  void* finalize_hint);
+
 typedef struct {
   // One of utf8name or name should be NULL.
   const char* utf8name;

package/package.json

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