emnapi 1.9.2 → 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) {
@@ -236,8 +236,8 @@ function __emnapi_close_handle_scope(_scope) {
 /* eslint-disable @typescript-eslint/indent */
 /* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/indent */
 /**
- * @__deps emscripten_resize_heap
  * @__sig ipjp
  */
 function _napi_adjust_external_memory(env, low, high, adjusted_value) {
@@ -248,33 +248,24 @@ function _napi_adjust_external_memory(env, low, high, adjusted_value) {
 #if WASM_BIGINT
     if (!high)
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    change_in_bytes = Number(low);
+    change_in_bytes = BigInt(low);
 #else
     if (!adjusted_value)
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    change_in_bytes = (low >>> 0) + (high * Math.pow(2, 32));
+    change_in_bytes = BigInt(low >>> 0) + (BigInt(high) << BigInt(32));
 #endif
-    if (change_in_bytes < 0) {
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    }
-    if (change_in_bytes > 0) {
-        var old_size = wasmMemory.buffer.byteLength;
-        var new_size = old_size + change_in_bytes;
-        if (!_emscripten_resize_heap(new_size)) {
-            return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
-        }
-    }
+    var adjusted_memory = emnapiCtx.adjustAmountOfExternalAllocatedMemory(change_in_bytes);
 #if WASM_BIGINT
     {{{ from64('high') }}};
     if (emnapiCtx.feature.supportBigInt) {
-        {{{ makeSetValue('high', 0, 'wasmMemory.buffer.byteLength', 'i64') }}};
+        {{{ makeSetValue('high', 0, 'adjusted_memory', 'i64') }}};
     }
     else {
-        emnapiSetValueI64(high, wasmMemory.buffer.byteLength);
+        emnapiSetValueI64(high, Number(adjusted_memory));
     }
 #else
     {{{ from64('adjusted_value') }}};
-    {{{ makeSetValue('adjusted_value', 0, 'wasmMemory.buffer.byteLength', 'i64') }}};
+    {{{ makeSetValue('adjusted_value', 0, 'adjusted_memory', 'i64') }}};
 #endif
     return envObject.clearLastError();
 }
@@ -308,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 () {
@@ -1064,8 +1055,7 @@ var emnapiExternalMemory = {
             }
             return view;
         }
-        var maybeOldWasmMemory = emnapiExternalMemory.isDetachedArrayBuffer(view.buffer) ||
-            ((typeof SharedArrayBuffer === 'function') && (view.buffer instanceof SharedArrayBuffer));
+        var maybeOldWasmMemory = emnapiExternalMemory.isDetachedArrayBuffer(view.buffer) || emnapiExternalMemory.isSharedArrayBuffer(view.buffer);
         if (maybeOldWasmMemory && emnapiExternalMemory.wasmMemoryViewTable.has(view)) {
             var info = emnapiExternalMemory.wasmMemoryViewTable.get(view);
             var Ctor = info.Ctor;
@@ -1095,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
  */
@@ -1296,13 +1353,12 @@ function _napi_get_typedarray_info(env, typedarray, type, length, data, arraybuf
         }
         {{{ makeSetValue('type', 0, 't', 'i32') }}};
     }
+    v = emnapiExternalMemory.getOrUpdateMemoryView(v);
     if (length) {
         {{{ from64('length') }}};
         {{{ makeSetValue('length', 0, 'v.length', SIZE_TYPE) }}};
     }
-    var buffer;
     if (data || arraybuffer) {
-        buffer = v.buffer;
         if (data) {
             {{{ from64('data') }}};
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -1312,7 +1368,7 @@ function _napi_get_typedarray_info(env, typedarray, type, length, data, arraybuf
         if (arraybuffer) {
             {{{ from64('arraybuffer') }}};
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            var ab = envObject.ensureHandleId(buffer);
+            var ab = envObject.ensureHandleId(v.buffer);
             {{{ makeSetValue('arraybuffer', 0, 'ab', '*') }}};
         }
     }
@@ -1356,14 +1412,12 @@ function _napi_get_dataview_info(env, dataview, byte_length, data, arraybuffer,
     if (!handle.isDataView()) {
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
     }
-    var v = handle.value;
+    var v = emnapiExternalMemory.getOrUpdateMemoryView(handle.value);
     if (byte_length) {
         {{{ from64('byte_length') }}};
         {{{ makeSetValue('byte_length', 0, 'v.byteLength', SIZE_TYPE) }}};
     }
-    var buffer;
     if (data || arraybuffer) {
-        buffer = v.buffer;
         if (data) {
             {{{ from64('data') }}};
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -1373,7 +1427,7 @@ function _napi_get_dataview_info(env, dataview, byte_length, data, arraybuffer,
         if (arraybuffer) {
             {{{ from64('arraybuffer') }}};
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            var ab = envObject.ensureHandleId(buffer);
+            var ab = envObject.ensureHandleId(v.buffer);
             {{{ makeSetValue('arraybuffer', 0, 'ab', '*') }}};
         }
     }
@@ -2867,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
@@ -3114,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
  */
@@ -3231,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') }}};
@@ -3273,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) {
@@ -5541,6 +5755,7 @@ function _napi_run_script(env, script, result) {
  * ```
  */
 var emnapiTSFN = {
+    _liveSet: {},
     offset: {
         __size__: 0,
         /* napi_ref */ resource: 0,
@@ -5549,6 +5764,9 @@ var emnapiTSFN = {
         /* size_t */ queue_size: 0,
         /* bool */ is_some: 0,
         /* void* */ queue: 0,
+        // Reuse uv_async_t storage as JS-side wakeup state: pending event + scheduled drain.
+        async_pending: 0,
+        async_u_fd: 0,
         /* size_t */ thread_count: 0,
         /* int32_t */ state: 0,
         /* atomic_uchar */ dispatch_state: 0,
@@ -5565,6 +5783,7 @@ var emnapiTSFN = {
         /* int32_t */ cond: 0
     },
     init: function () {
+        emnapiTSFN._liveSet = new Set();
 #if MEMORY64
         emnapiTSFN.offset.__size__ = 320 /* NapiTSFNOffset64.__size__ */;
         emnapiTSFN.offset.resource = 0 /* NapiTSFNOffset64.async_resource_resource */;
@@ -5573,6 +5792,8 @@ var emnapiTSFN = {
         emnapiTSFN.offset.queue_size = 88 /* NapiTSFNOffset64.queue_size */;
         emnapiTSFN.offset.is_some = 24 /* NapiTSFNOffset64.async_resource_is_some */;
         emnapiTSFN.offset.queue = 96 /* NapiTSFNOffset64.queue */;
+        emnapiTSFN.offset.async_pending = 232 /* NapiTSFNOffset64.async_pending */;
+        emnapiTSFN.offset.async_u_fd = 160 /* NapiTSFNOffset64.async_u_fd */;
         emnapiTSFN.offset.thread_count = 240 /* NapiTSFNOffset64.thread_count */;
         emnapiTSFN.offset.state = 248 /* NapiTSFNOffset64.state */;
         emnapiTSFN.offset.dispatch_state = 252 /* NapiTSFNOffset64.dispatch_state */;
@@ -5595,6 +5816,8 @@ var emnapiTSFN = {
         emnapiTSFN.offset.queue_size = 60 /* NapiTSFNOffset32.queue_size */;
         emnapiTSFN.offset.is_some = 24 /* NapiTSFNOffset32.async_resource_is_some */;
         emnapiTSFN.offset.queue = 64 /* NapiTSFNOffset32.queue */;
+        emnapiTSFN.offset.async_pending = 132 /* NapiTSFNOffset32.async_pending */;
+        emnapiTSFN.offset.async_u_fd = 96 /* NapiTSFNOffset32.async_u_fd */;
         emnapiTSFN.offset.thread_count = 136 /* NapiTSFNOffset32.thread_count */;
         emnapiTSFN.offset.state = 140 /* NapiTSFNOffset32.state */;
         emnapiTSFN.offset.dispatch_state = 144 /* NapiTSFNOffset32.dispatch_state */;
@@ -5613,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);
@@ -5634,7 +5857,10 @@ var emnapiTSFN = {
                 var type = __emnapi__.type;
                 var payload = __emnapi__.payload;
                 if (type === 'tsfn-send') {
-                    emnapiTSFN.dispatch(payload.tsfn);
+                    var pendng = payload.tsfn + emnapiTSFN.offset.async_pending;
+                    if (Atomics.load(new Int32Array(wasmMemory.buffer), pendng >>> 2) !== 0) {
+                        emnapiTSFN.enqueue(payload.tsfn);
+                    }
                 }
             }
         };
@@ -5669,6 +5895,12 @@ var emnapiTSFN = {
     destroyQueue: function (func) {
         var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
         if (queue) {
+            var node = emnapiTSFN.loadSizeTypeValue(queue, false);
+            while (node !== 0) {
+                var next = emnapiTSFN.loadSizeTypeValue(node + {{{ POINTER_SIZE }}}, false);
+                _free({{{ to64('node') }}});
+                node = next;
+            }
             _free({{{ to64('queue') }}});
         }
     },
@@ -6027,6 +6259,7 @@ var emnapiTSFN = {
         }
     },
     destroy: function (func) {
+        emnapiTSFN._liveSet.delete(func);
         emnapiTSFN.destroyQueue(func);
         emnapiTSFN.releaseResources(func);
         _free({{{ to64('func') }}});
@@ -6121,6 +6354,7 @@ var emnapiTSFN = {
                 return;
             }
             emnapiTSFN.setHandlesClosing(func, 1);
+            Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.async_pending) >>> 2, 1);
             emnapiCtx.feature.setImmediate(function () {
                 emnapiTSFN.finalize(func);
             });
@@ -6224,25 +6458,85 @@ var emnapiTSFN = {
             emnapiTSFN.send(func);
         }
     },
-    send: function (func) {
-        var current_state = Atomics.or(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >>> 2, 1 << 1);
-        if ((current_state & 1) === 1) {
+    enqueue: function (func) {
+        // `pending` means a worker thread has requested a wakeup that has not
+        // been drained on the main thread yet.
+        var pending = func + emnapiTSFN.offset.async_pending;
+        // `scheduled` prevents queueing the same main-thread drain chain more than
+        // once while a previous wakeup is still in flight.
+        var scheduled = func + emnapiTSFN.offset.async_u_fd;
+        var i32a = new Int32Array(wasmMemory.buffer);
+        if (Atomics.exchange(i32a, scheduled >>> 2, 1) !== 0) {
             return;
         }
-        if ((typeof ENVIRONMENT_IS_PTHREAD !== 'undefined') && ENVIRONMENT_IS_PTHREAD) {
-            postMessage({
-                __emnapi__: {
-                    type: 'tsfn-send',
-                    payload: {
-                        tsfn: func
+        // Match uv_async_send-style coalescing in JS: the first turn represents
+        // the wakeup reaching the main thread, and the second turn performs the
+        // actual TSFN drain after nearby Send/Signal calls have had a chance to
+        // collapse into the shared AsyncProgressWorker state.
+        emnapiCtx.feature.setImmediate(function () {
+            if (!emnapiTSFN._liveSet.has(func)) {
+                return;
+            }
+            if (Atomics.load(i32a, pending >>> 2) === 0) {
+                Atomics.store(i32a, scheduled >>> 2, 0);
+                return;
+            }
+            emnapiCtx.feature.setImmediate(function () {
+                try {
+                    // Consume the coalesced wakeup once, then let dispatch() observe any
+                    // queue mutations through dispatch_state like the C implementation.
+                    if (Atomics.exchange(i32a, pending >>> 2, 0) === 0) {
+                        return;
+                    }
+                    // After destroy(), the func address is freed.  Skip dispatch
+                    // to avoid use-after-free (JS-side lifecycle check).
+                    if (!emnapiTSFN._liveSet.has(func)) {
+                        return;
+                    }
+                    emnapiTSFN.dispatch(func);
+                }
+                finally {
+                    // Allow a later wakeup to schedule a new drain chain. If another
+                    // worker-thread send raced with this drain, enqueue one more turn.
+                    if (emnapiTSFN._liveSet.has(func)) {
+                        Atomics.store(i32a, scheduled >>> 2, 0);
+                        if (Atomics.load(i32a, pending >>> 2) !== 0) {
+                            emnapiTSFN.enqueue(func);
+                        }
                     }
                 }
             });
+        });
+    },
+    send: function (func) {
+        var current_state = Atomics.or(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >>> 2, 1 << 1);
+        if ((current_state & 1) === 1) {
+            return;
         }
-        else {
-            emnapiCtx.feature.setImmediate(function () {
-                emnapiTSFN.dispatch(func);
-            });
+        var pendng = func + emnapiTSFN.offset.async_pending;
+        // A wakeup is already pending, so this send only needs to leave the queued
+        // work in the TSFN queue and let the existing drain pick it up.
+        if (Atomics.load(new Int32Array(wasmMemory.buffer), pendng >>> 2) !== 0) {
+            return;
+        }
+        if (Atomics.exchange(new Int32Array(wasmMemory.buffer), pendng >>> 2, 1) === 0) {
+            if ((typeof ENVIRONMENT_IS_PTHREAD !== 'undefined') && ENVIRONMENT_IS_PTHREAD) {
+                // Worker threads only post a wakeup token. Main-thread draining is
+                // serialized by enqueue() once the message is received.
+                postMessage({
+                    __emnapi__: {
+                        type: 'tsfn-send',
+                        payload: {
+                            tsfn: func
+                        }
+                    }
+                });
+            }
+            else {
+                // On the main thread we can skip the cross-thread hop and schedule the
+                // coalesced drain chain directly.
+                emnapiTSFN.enqueue(func);
+            }
         }
     }
 };
@@ -6329,6 +6623,7 @@ function _napi_create_threadsafe_function(env, func, async_resource, async_resou
     {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.finalize_cb', 'thread_finalize_cb', '*') }}};
     {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.call_js_cb', 'call_js_cb', '*') }}};
     emnapiCtx.addCleanupHook(envObject, emnapiTSFN.cleanup, tsfn);
+    emnapiTSFN._liveSet.add(tsfn);
     envObject.ref();
     __emnapi_runtime_keepalive_push();
     emnapiCtx.increaseWaitingRequestCounter();
@@ -6931,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,
@@ -7037,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,
@@ -7045,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",
@@ -7066,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",
@@ -7079,7 +7386,7 @@ function _napi_get_version(env, result) {
     napi_add_env_cleanup_hook__deps: ["$emnapiCtx"],
     napi_add_env_cleanup_hook__sig: "ippp",
     napi_adjust_external_memory: _napi_adjust_external_memory,
-    napi_adjust_external_memory__deps: ["$emnapiCtx", "$emnapiSetValueI64", "emscripten_resize_heap"],
+    napi_adjust_external_memory__deps: ["$emnapiCtx", "$emnapiSetValueI64"],
     napi_adjust_external_memory__sig: "ipjp",
     napi_call_function: _napi_call_function,
     napi_call_function__deps: ["$emnapiCtx"],
@@ -7498,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,8 +6,8 @@
 #include "emnapi_common.h"
 
 #define EMNAPI_MAJOR_VERSION 1
-#define EMNAPI_MINOR_VERSION 9
-#define EMNAPI_PATCH_VERSION 2
+#define EMNAPI_MINOR_VERSION 11
+#define EMNAPI_PATCH_VERSION 0
 
 typedef enum {
   emnapi_runtime,
@@ -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.9.2",
+  "version": "1.11.0",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "gypfile": false,