emnapi 1.10.0 → 1.11.1

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);
@@ -5631,7 +5858,7 @@ var emnapiTSFN = {
                 var payload = __emnapi__.payload;
                 if (type === 'tsfn-send') {
                     var pendng = payload.tsfn + emnapiTSFN.offset.async_pending;
-                    if (Atomics.load(new Int32Array(wasmMemory.buffer), pendng >>> 2) !== 0) {
+                    if (Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), pendng >>> 2) !== 0) {
                         emnapiTSFN.enqueue(payload.tsfn);
                     }
                 }
@@ -5655,13 +5882,28 @@ var emnapiTSFN = {
         }
         return true;
     },
+    /**
+     * When another thread grows the shared WebAssembly.Memory, this agent's
+     * cached `wasmMemory.buffer` may still have the old shorter length
+     * (V8 refreshes it lazily). If a pointer derived from shared memory lies
+     * beyond the cached length, `wasmMemory.grow(0)` forces the agent to
+     * observe the current memory size and refreshes the buffer.
+     */
+    ensureBufferFor: function (end) {
+        var buffer = wasmMemory.buffer;
+        if (end > buffer.byteLength) {
+            wasmMemory.grow(0);
+            buffer = wasmMemory.buffer;
+        }
+        return buffer;
+    },
     initQueue: function (func) {
         var size = 2 * {{{ POINTER_SIZE }}};
         var queue = _malloc({{{ to64('size') }}});
         if (!queue)
             return false;
         {{{ from64('queue') }}};
-        new Uint8Array(wasmMemory.buffer, queue, size).fill(0);
+        new Uint8Array(emnapiTSFN.ensureBufferFor(queue + size), queue, size).fill(0);
         emnapiTSFN.storeSizeTypeValue(func + emnapiTSFN.offset.queue, queue, false);
         return true;
     },
@@ -5768,7 +6010,7 @@ var emnapiTSFN = {
         var mutex = {
             lock: function () {
                 var isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE;
-                var i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                var i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1);
                 if (isBrowserMain) {
                     while (true) {
                         var oldValue = Atomics.compareExchange(i32a, 0, 0, 10);
@@ -5791,7 +6033,7 @@ var emnapiTSFN = {
               return new Promise<void>(resolve => {
                 const again = (): void => { fn() }
                 const fn = (): void => {
-                  const i32a = new Int32Array(wasmMemory.buffer, index, 1)
+                  const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1)
                   const oldValue = Atomics.compareExchange(i32a, 0, 0, 10)
                   if (oldValue === 0) {
                     resolve()
@@ -5803,7 +6045,7 @@ var emnapiTSFN = {
               })
             }, */
             unlock: function () {
-                var i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                var i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1);
                 var oldValue = Atomics.compareExchange(i32a, 0, 10, 0);
                 if (oldValue !== 10) {
                     throw new Error('Tried to unlock while not holding the mutex');
@@ -5837,14 +6079,14 @@ var emnapiTSFN = {
         var mutex = emnapiTSFN.getMutex(func);
         var cond = {
             wait: function () {
-                var i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                var i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1);
                 var value = Atomics.load(i32a, 0);
                 mutex.unlock();
                 Atomics.wait(i32a, 0, value);
                 mutex.lock();
             },
             /* waitAsync () {
-              const i32a = new Int32Array(wasmMemory.buffer, index, 1)
+              const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1)
               const value = Atomics.load(i32a, 0)
               mutex.unlock()
               const lock = (): Promise<void> => mutex.lockAsync()
@@ -5855,7 +6097,7 @@ var emnapiTSFN = {
               }
             }, */
             signal: function () {
-                var i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                var i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1);
                 Atomics.add(i32a, 0, 1);
                 Atomics.notify(i32a, 0, 1);
             }
@@ -5869,10 +6111,10 @@ var emnapiTSFN = {
         var offset = emnapiTSFN.offset.queue_size;
         var arr, index;
 #if MEMORY64
-        arr = new BigUint64Array(wasmMemory.buffer);
+        arr = new BigUint64Array(emnapiTSFN.ensureBufferFor(func + offset + 8));
         index = (func + offset) >>> 3;
 #else
-        arr = new Uint32Array(wasmMemory.buffer);
+        arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4));
         index = (func + offset) >>> 2;
 #endif
         Atomics.add(arr, index, {{{ to64('1') }}});
@@ -5881,10 +6123,10 @@ var emnapiTSFN = {
         var offset = emnapiTSFN.offset.queue_size;
         var arr, index;
 #if MEMORY64
-        arr = new BigUint64Array(wasmMemory.buffer);
+        arr = new BigUint64Array(emnapiTSFN.ensureBufferFor(func + offset + 8));
         index = (func + offset) >>> 3;
 #else
-        arr = new Uint32Array(wasmMemory.buffer);
+        arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4));
         index = (func + offset) >>> 2;
 #endif
         Atomics.sub(arr, index, {{{ to64('1') }}});
@@ -5896,10 +6138,10 @@ var emnapiTSFN = {
         var offset = emnapiTSFN.offset.thread_count;
         var arr, index;
 #if MEMORY64
-        arr = new BigUint64Array(wasmMemory.buffer);
+        arr = new BigUint64Array(emnapiTSFN.ensureBufferFor(func + offset + 8));
         index = (func + offset) >>> 3;
 #else
-        arr = new Uint32Array(wasmMemory.buffer);
+        arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4));
         index = (func + offset) >>> 2;
 #endif
         Atomics.add(arr, index, {{{ to64('1') }}});
@@ -5908,28 +6150,28 @@ var emnapiTSFN = {
         var offset = emnapiTSFN.offset.thread_count;
         var arr, index;
 #if MEMORY64
-        arr = new BigUint64Array(wasmMemory.buffer);
+        arr = new BigUint64Array(emnapiTSFN.ensureBufferFor(func + offset + 8));
         index = (func + offset) >>> 3;
 #else
-        arr = new Uint32Array(wasmMemory.buffer);
+        arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4));
         index = (func + offset) >>> 2;
 #endif
         Atomics.sub(arr, index, {{{ to64('1') }}});
     },
     getState: function (func) {
-        return Atomics.load(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.state) >>> 2);
+        return Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.state + 4)), (func + emnapiTSFN.offset.state) >>> 2);
     },
     setState: function (func, value) {
-        Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.state) >>> 2, value);
+        Atomics.store(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.state + 4)), (func + emnapiTSFN.offset.state) >>> 2, value);
     },
     getHandlesClosing: function (func) {
-        return Atomics.load(new Int8Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing));
+        return Atomics.load(new Int8Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.handles_closing + 1)), (func + emnapiTSFN.offset.handles_closing));
     },
     setHandlesClosing: function (func, value) {
-        Atomics.store(new Int8Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing), value);
+        Atomics.store(new Int8Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.handles_closing + 1)), (func + emnapiTSFN.offset.handles_closing), value);
     },
     getDispatchState: function (func) {
-        return Atomics.load(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >>> 2);
+        return Atomics.load(new Uint32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.dispatch_state + 4)), (func + emnapiTSFN.offset.dispatch_state) >>> 2);
     },
     getContext: function (func) {
         return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.context, false);
@@ -5960,20 +6202,20 @@ var emnapiTSFN = {
         var arr;
         if (unsigned) {
 #if MEMORY64
-            arr = new BigUint64Array(wasmMemory.buffer);
+            arr = new BigUint64Array(emnapiTSFN.ensureBufferFor(offset + 8));
             ret = Number(Atomics.load(arr, offset >>> 3));
 #else
-            arr = new Uint32Array(wasmMemory.buffer);
+            arr = new Uint32Array(emnapiTSFN.ensureBufferFor(offset + 4));
             ret = Atomics.load(arr, offset >>> 2);
 #endif
             return ret;
         }
         else {
 #if MEMORY64
-            arr = new BigInt64Array(wasmMemory.buffer);
+            arr = new BigInt64Array(emnapiTSFN.ensureBufferFor(offset + 8));
             ret = Number(Atomics.load(arr, offset >>> 3));
 #else
-            arr = new Int32Array(wasmMemory.buffer);
+            arr = new Int32Array(emnapiTSFN.ensureBufferFor(offset + 4));
             ret = Atomics.load(arr, offset >>> 2);
 #endif
             return ret;
@@ -5983,20 +6225,20 @@ var emnapiTSFN = {
         var arr;
         if (unsigned) {
 #if MEMORY64
-            arr = new BigUint64Array(wasmMemory.buffer);
+            arr = new BigUint64Array(emnapiTSFN.ensureBufferFor(offset + 8));
             Atomics.store(arr, offset >>> 3, BigInt(value));
 #else
-            arr = new Uint32Array(wasmMemory.buffer);
+            arr = new Uint32Array(emnapiTSFN.ensureBufferFor(offset + 4));
             Atomics.store(arr, offset >>> 2, value);
 #endif
             return undefined;
         }
         else {
 #if MEMORY64
-            arr = new BigInt64Array(wasmMemory.buffer);
+            arr = new BigInt64Array(emnapiTSFN.ensureBufferFor(offset + 8));
             Atomics.store(arr, offset >>> 3, BigInt(value >>> 0));
 #else
-            arr = new Int32Array(wasmMemory.buffer);
+            arr = new Int32Array(emnapiTSFN.ensureBufferFor(offset + 4));
             Atomics.store(arr, offset >>> 2, value >>> 0);
 #endif
             return undefined;
@@ -6013,18 +6255,20 @@ var emnapiTSFN = {
             }
             var resource = emnapiTSFN.getResource(func);
             emnapiCtx.refStore.get(resource).dispose();
+            emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.is_some + 1);
             {{{ makeSetValue('func', 'emnapiTSFN.offset.is_some', '0', 'i8') }}};
             emnapiCtx.removeCleanupHook(envObject, emnapiTSFN.cleanup, func);
             envObject.unref();
-            var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >>> 2;
-            var arr = new Uint32Array(wasmMemory.buffer);
+            var asyncRefAddress = func + emnapiTSFN.offset.async_ref;
+            var asyncRefOffset = asyncRefAddress >>> 2;
+            var arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4));
             if (Atomics.load(arr, asyncRefOffset) > 0) {
                 Atomics.store(arr, asyncRefOffset, 0);
                 __emnapi_runtime_keepalive_pop();
                 emnapiCtx.decreaseWaitingRequestCounter();
             }
             if (emnapiNodeBinding) {
-                var view = new DataView(wasmMemory.buffer);
+                var view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8));
                 var asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);
                 var triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);
                 __emnapi_node_emit_async_destroy(asyncId, triggerAsyncId);
@@ -6089,7 +6333,7 @@ var emnapiTSFN = {
                     var resource = emnapiTSFN.getResource(func);
                     var resource_value = emnapiCtx.refStore.get(resource).get();
                     var resourceObject = emnapiCtx.handleStore.get(resource_value).value;
-                    var view = new DataView(wasmMemory.buffer);
+                    var view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8));
                     var asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);
                     var triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);
                     emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {
@@ -6127,7 +6371,7 @@ var emnapiTSFN = {
                 return;
             }
             emnapiTSFN.setHandlesClosing(func, 1);
-            Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.async_pending) >>> 2, 1);
+            Atomics.store(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.async_pending + 4)), (func + emnapiTSFN.offset.async_pending) >>> 2, 1);
             emnapiCtx.feature.setImmediate(function () {
                 emnapiTSFN.finalize(func);
             });
@@ -6199,7 +6443,7 @@ var emnapiTSFN = {
                     var resource = emnapiTSFN.getResource(func);
                     var resource_value = emnapiCtx.refStore.get(resource).get();
                     var resourceObject = emnapiCtx.handleStore.get(resource_value).value;
-                    var view = new DataView(wasmMemory.buffer);
+                    var view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8));
                     emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {
                         asyncId: view.getFloat64(func + emnapiTSFN.offset.async_id, true),
                         triggerAsyncId: view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true)
@@ -6218,8 +6462,9 @@ var emnapiTSFN = {
     dispatch: function (func) {
         var has_more = true;
         var iterations_left = 1000;
-        var ui32a = new Uint32Array(wasmMemory.buffer);
-        var index = (func + emnapiTSFN.offset.dispatch_state) >>> 2;
+        var dispatchStateAddress = func + emnapiTSFN.offset.dispatch_state;
+        var ui32a = new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4));
+        var index = dispatchStateAddress >>> 2;
         while (has_more && --iterations_left !== 0) {
             Atomics.store(ui32a, index, 1);
             has_more = emnapiTSFN.dispatchOne(func);
@@ -6238,7 +6483,7 @@ var emnapiTSFN = {
         // `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);
+        var i32a = new Int32Array(emnapiTSFN.ensureBufferFor(Math.max(pending, scheduled) + 4));
         if (Atomics.exchange(i32a, scheduled >>> 2, 1) !== 0) {
             return;
         }
@@ -6282,17 +6527,18 @@ var emnapiTSFN = {
         });
     },
     send: function (func) {
-        var current_state = Atomics.or(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >>> 2, 1 << 1);
+        var dispatchStateAddress = func + emnapiTSFN.offset.dispatch_state;
+        var current_state = Atomics.or(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), dispatchStateAddress >>> 2, 1 << 1);
         if ((current_state & 1) === 1) {
             return;
         }
         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) {
+        if (Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), pendng >>> 2) !== 0) {
             return;
         }
-        if (Atomics.exchange(new Int32Array(wasmMemory.buffer), pendng >>> 2, 1) === 0) {
+        if (Atomics.exchange(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), 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.
@@ -6375,7 +6621,7 @@ function _napi_create_threadsafe_function(env, func, async_resource, async_resou
     if (!tsfn)
         return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
     {{{ from64('tsfn') }}};
-    new Uint8Array(wasmMemory.buffer).subarray(tsfn, tsfn + sizeofTSFN).fill(0);
+    new Uint8Array(emnapiTSFN.ensureBufferFor(tsfn + sizeofTSFN)).subarray(tsfn, tsfn + sizeofTSFN).fill(0);
     var resourceRef = emnapiCtx.createReference(envObject, resource, 1, 1 /* ReferenceOwnership.kUserland */);
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     var resource_ = resourceRef.id;
@@ -6488,8 +6734,9 @@ function _napi_unref_threadsafe_function(env, func) {
         return 1 /* napi_status.napi_invalid_arg */;
     }
     {{{ from64('func') }}};
-    var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >>> 2;
-    var arr = new Uint32Array(wasmMemory.buffer);
+    var asyncRefAddress = func + emnapiTSFN.offset.async_ref;
+    var asyncRefOffset = asyncRefAddress >>> 2;
+    var arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4));
     var currentValue = Atomics.load(arr, asyncRefOffset);
     if (currentValue > 0) {
         Atomics.store(arr, asyncRefOffset, currentValue - 1);
@@ -6507,8 +6754,9 @@ function _napi_ref_threadsafe_function(env, func) {
         return 1 /* napi_status.napi_invalid_arg */;
     }
     {{{ from64('func') }}};
-    var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >>> 2;
-    var arr = new Uint32Array(wasmMemory.buffer);
+    var asyncRefAddress = func + emnapiTSFN.offset.async_ref;
+    var asyncRefOffset = asyncRefAddress >>> 2;
+    var arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4));
     var currentValue = Atomics.load(arr, asyncRefOffset);
     if (!currentValue) {
         __emnapi_runtime_keepalive_push();
@@ -6999,14 +7247,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 +7357,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 +7367,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 +7391,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 +7826,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 10
-#define EMNAPI_PATCH_VERSION 0
+#define EMNAPI_MINOR_VERSION 11
+#define EMNAPI_PATCH_VERSION 1
 
 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.10.0",
+  "version": "1.11.1",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "gypfile": false,