emnapi 1.9.2 → 1.10.0

package/dist/library_napi.js

@@ -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();
 }
@@ -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;
@@ -1296,13 +1286,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 +1301,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 +1345,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 +1360,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', '*') }}};
         }
     }
@@ -5541,6 +5528,7 @@ function _napi_run_script(env, script, result) {
  * ```
  */
 var emnapiTSFN = {
+    _liveSet: {},
     offset: {
         __size__: 0,
         /* napi_ref */ resource: 0,
@@ -5549,6 +5537,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 +5556,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 +5565,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 +5589,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 */;
@@ -5634,7 +5630,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 +5668,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 +6032,7 @@ var emnapiTSFN = {
         }
     },
     destroy: function (func) {
+        emnapiTSFN._liveSet.delete(func);
         emnapiTSFN.destroyQueue(func);
         emnapiTSFN.releaseResources(func);
         _free({{{ to64('func') }}});
@@ -6121,6 +6127,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 +6231,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 +6396,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();
@@ -7079,7 +7147,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"],

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 10
+#define EMNAPI_PATCH_VERSION 0
 
 typedef enum {
   emnapi_runtime,

package/package.json

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