emnapi 1.11.0 → 2.0.0-alpha.2

package/dist/library_threadsafe_function.js

@@ -0,0 +1,1178 @@
+//#region src/emscripten/init.ts
+/* eslint-disable @stylistic/indent */
+var emnapiCtx$1 = undefined;
+var emnapiEnv = undefined;
+// export var emnapiRuntimeModuleExports: any = undefined!
+var emnapiNodeBinding$1 = undefined;
+var emnapiAsyncWorkPoolSize = 0;
+const emnapiModule = {
+    exports: {},
+    loaded: false,
+    filename: ''
+};
+/**
+ * @__deps emnapi_create_env
+ * @__deps emnapi_delete_env
+ */
+function emnapiInit(options) {
+    if (emnapiModule.loaded)
+        return emnapiModule.exports;
+    if (typeof options !== 'object' || options === null) {
+        throw new TypeError('Invalid emnapi init option');
+    }
+    const context = options.context;
+    if (typeof context !== 'object' || context === null) {
+        throw new TypeError("Invalid `options.context`. Use `import { getDefaultContext } from '@emnapi/runtime'`");
+    }
+    emnapiCtx$1 = context;
+    const filename = typeof options.filename === 'string' ? options.filename : '';
+    emnapiModule.filename = filename;
+    if ('nodeBinding' in options) {
+        const nodeBinding = options.nodeBinding;
+        if (typeof nodeBinding !== 'object' || nodeBinding === null) {
+            throw new TypeError('Invalid `options.nodeBinding`. Use @emnapi/node-binding package');
+        }
+        emnapiNodeBinding$1 = nodeBinding;
+    }
+    if ('asyncWorkPoolSize' in options) {
+        if (typeof options.asyncWorkPoolSize !== 'number') {
+            throw new TypeError('options.asyncWorkPoolSize must be a integer');
+        }
+        emnapiAsyncWorkPoolSize = options.asyncWorkPoolSize >> 0;
+        if (emnapiAsyncWorkPoolSize > 1024) {
+            emnapiAsyncWorkPoolSize = 1024;
+        }
+        else if (emnapiAsyncWorkPoolSize < -1024) {
+            emnapiAsyncWorkPoolSize = -1024;
+        }
+    }
+    const NODE_MODULE_VERSION = 127 /* Version.NODE_MODULE_VERSION */;
+    const nodeRegisterModuleSymbol = `node_register_module_v${NODE_MODULE_VERSION}`;
+    const emscriptenExportedSymbol = `_${nodeRegisterModuleSymbol}`;
+    if (typeof Module[emscriptenExportedSymbol] === 'function') {
+        const scope = emnapiCtx$1.isolate.openScope();
+        try {
+            const exports = emnapiModule.exports;
+            const exportsHandle = scope.add(exports);
+            const moduleHandle = scope.add(emnapiModule);
+            Module[emscriptenExportedSymbol]({{{ to64('exportsHandle') }}}, {{{ to64('moduleHandle') }}}, {{{ to64('5') }}});
+        }
+        catch (err) {
+            if (err !== 'unwind') {
+                throw err;
+            }
+        }
+        finally {
+            emnapiCtx$1.isolate.closeScope(scope);
+        }
+        emnapiModule.loaded = true;
+        delete emnapiModule.envObject;
+        return emnapiModule.exports;
+    }
+    const find = Object.keys(Module).filter(k => k.startsWith('_node_register_module_v'));
+    if (find.length > 0) {
+        throw new Error(`The module${emnapiModule.filename ? ` '${emnapiModule.filename}'` : ''}
+was compiled against a different Node.js version using
+NODE_MODULE_VERSION ${find[0].slice(23)}. This version of Node.js requires
+NODE_MODULE_VERSION ${NODE_MODULE_VERSION}.`);
+    }
+    const moduleApiVersion = Module._node_api_module_get_api_version_v1();
+    const envObject = emnapiModule.envObject || (() => {
+        let address = _emnapi_create_env();
+        {{{ from64('address') }}};
+        address += 8;
+        const envObject = emnapiModule.envObject = emnapiEnv = emnapiCtx$1.createEnv(filename, moduleApiVersion, {
+            address,
+            deleteEnv: (ptr) => {
+                _emnapi_delete_env({{{ to64('ptr') }}} - {{{ to64('8') }}});
+            },
+            setLastError(env, error_code, engine_error_code, engine_reserved) {
+                {{{ from64('env') }}};
+                env -= 8;
+                {{{ from64('engine_reserved') }}};
+#if MEMORY64
+                {{{ makeSetValue('env', 60 /* NapiEnvOffset64.last_error_error_code */, 'error_code', 'i32') }}};
+                {{{ makeSetValue('env', 56 /* NapiEnvOffset64.last_error_engine_error_code */, 'engine_error_code', 'u32') }}};
+                {{{ makeSetValue('env', 48 /* NapiEnvOffset64.last_error_engine_reserved */, 'engine_reserved', '*') }}};
+#else
+                {{{ makeSetValue('env', 40 /* NapiEnvOffset32.last_error_error_code */, 'error_code', 'i32') }}};
+                {{{ makeSetValue('env', 36 /* NapiEnvOffset32.last_error_engine_error_code */, 'engine_error_code', 'u32') }}};
+                {{{ makeSetValue('env', 32 /* NapiEnvOffset32.last_error_engine_reserved */, 'engine_reserved', '*') }}};
+#endif
+                return error_code;
+            },
+            makeDynCall_vppp: (cb) => {{{ makeDynCall('vppp', 'cb') }}},
+            makeDynCall_vp: (cb) => {{{ makeDynCall('vp', 'cb') }}},
+            abort
+        }, emnapiNodeBinding$1);
+#if MEMORY64
+        {{{ makeSetValue('address - 8', 32 /* NapiEnvOffset64.id */, 'envObject.id', 'u32') }}};
+#else
+        {{{ makeSetValue('address - 8', 24 /* NapiEnvOffset32.id */, 'envObject.id', 'u32') }}};
+#endif
+        return envObject;
+    })();
+    const scope = emnapiCtx$1.openScope(envObject);
+    try {
+        envObject.callIntoModule((envObject) => {
+            const exports = emnapiModule.exports;
+            const env = envObject.bridge.address;
+            const exportsHandle = scope.add(exports);
+            const napiValue = Module._napi_register_wasm_v1({{{ to64('env') }}}, {{{ to64('exportsHandle') }}});
+            emnapiModule.exports = (!napiValue) ? exports : emnapiCtx$1.jsValueFromNapiValue(napiValue);
+        });
+    }
+    catch (err) {
+        if (err !== 'unwind') {
+            throw err;
+        }
+    }
+    finally {
+        emnapiCtx$1.closeScope(envObject, scope);
+    }
+    emnapiModule.loaded = true;
+    delete emnapiModule.envObject;
+    return emnapiModule.exports;
+}
+/**
+ * @__sig i
+ */
+function _emnapi_async_work_pool_size() {
+    return Math.abs(emnapiAsyncWorkPoolSize);
+}
+//#endregion src/emscripten/init.ts
+//#region src/macro.ts
+//#endregion src/macro.ts
+//#region src/threadsafe-function.ts
+/* eslint-disable @stylistic/indent */
+/**
+ * @__deps malloc
+ * @__deps free
+ * @__deps $emnapiCtx
+ * @__deps $emnapiEnv
+ * @__deps $emnapiNodeBinding
+ * @__deps _emnapi_node_emit_async_destroy
+ * @__deps _emnapi_runtime_keepalive_pop
+ * @__postset
+ * ```
+ * emnapiTSFN.init();
+ * ```
+ */
+const emnapiTSFN = {
+    _liveSet: {},
+    offset: {
+        __size__: 0,
+        /* napi_ref */ resource: 0,
+        /* double */ async_id: 0,
+        /* double */ trigger_async_id: 0,
+        /* 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,
+        /* void* */ context: 0,
+        /* size_t */ max_queue_size: 0,
+        /* napi_ref */ ref: 0,
+        /* napi_env */ env: 0,
+        /* void* */ finalize_data: 0,
+        /* napi_finalize */ finalize_cb: 0,
+        /* napi_threadsafe_function_call_js */ call_js_cb: 0,
+        /* bool */ handles_closing: 0,
+        /* bool */ async_ref: 0,
+        /* int32_t */ mutex: 0,
+        /* int32_t */ cond: 0,
+    },
+    init() {
+        emnapiTSFN._liveSet = new Set();
+#if MEMORY64
+        emnapiTSFN.offset.__size__ = 320 /* NapiTSFNOffset64.__size__ */;
+        emnapiTSFN.offset.resource = 0 /* NapiTSFNOffset64.async_resource_resource */;
+        emnapiTSFN.offset.async_id = 8 /* NapiTSFNOffset64.async_resource_async_context_async_id */;
+        emnapiTSFN.offset.trigger_async_id = 16 /* NapiTSFNOffset64.async_resource_async_context_trigger_async_id */;
+        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 */;
+        emnapiTSFN.offset.context = 256 /* NapiTSFNOffset64.context */;
+        emnapiTSFN.offset.max_queue_size = 264 /* NapiTSFNOffset64.max_queue_size */;
+        emnapiTSFN.offset.ref = 272 /* NapiTSFNOffset64.ref */;
+        emnapiTSFN.offset.env = 280 /* NapiTSFNOffset64.env */;
+        emnapiTSFN.offset.finalize_data = 288 /* NapiTSFNOffset64.finalize_data */;
+        emnapiTSFN.offset.finalize_cb = 296 /* NapiTSFNOffset64.finalize_cb */;
+        emnapiTSFN.offset.call_js_cb = 304 /* NapiTSFNOffset64.call_js_cb */;
+        emnapiTSFN.offset.handles_closing = 312 /* NapiTSFNOffset64.handles_closing */;
+        emnapiTSFN.offset.async_ref = 316 /* NapiTSFNOffset64.async_ref */;
+        emnapiTSFN.offset.mutex = 32 /* NapiTSFNOffset64.mutex */;
+        emnapiTSFN.offset.cond = 80 /* NapiTSFNOffset64.cond */;
+#else
+        emnapiTSFN.offset.__size__ = 184 /* NapiTSFNOffset32.__size__ */;
+        emnapiTSFN.offset.resource = 0 /* NapiTSFNOffset32.async_resource_resource */;
+        emnapiTSFN.offset.async_id = 8 /* NapiTSFNOffset32.async_resource_async_context_async_id */;
+        emnapiTSFN.offset.trigger_async_id = 16 /* NapiTSFNOffset32.async_resource_async_context_trigger_async_id */;
+        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 */;
+        emnapiTSFN.offset.context = 148 /* NapiTSFNOffset32.context */;
+        emnapiTSFN.offset.max_queue_size = 152 /* NapiTSFNOffset32.max_queue_size */;
+        emnapiTSFN.offset.ref = 156 /* NapiTSFNOffset32.ref */;
+        emnapiTSFN.offset.env = 160 /* NapiTSFNOffset32.env */;
+        emnapiTSFN.offset.finalize_data = 164 /* NapiTSFNOffset32.finalize_data */;
+        emnapiTSFN.offset.finalize_cb = 168 /* NapiTSFNOffset32.finalize_cb */;
+        emnapiTSFN.offset.call_js_cb = 172 /* NapiTSFNOffset32.call_js_cb */;
+        emnapiTSFN.offset.handles_closing = 176 /* NapiTSFNOffset32.handles_closing */;
+        emnapiTSFN.offset.async_ref = 180 /* NapiTSFNOffset32.async_ref */;
+        emnapiTSFN.offset.mutex = 32 /* NapiTSFNOffset32.mutex */;
+        emnapiTSFN.offset.cond = 56 /* NapiTSFNOffset32.cond */;
+#endif
+        emnapiTSFN.offset.mutex = emnapiTSFN.offset.mutex + 4;
+        if (typeof PThread !== 'undefined') {
+            PThread.unusedWorkers.forEach(emnapiTSFN.addListener);
+            Object.values(PThread.pthreads).forEach(emnapiTSFN.addListener);
+            const __original_getNewWorker = PThread.getNewWorker;
+            PThread.getNewWorker = function () {
+                const r = __original_getNewWorker.apply(this, arguments);
+                emnapiTSFN.addListener(r);
+                return r;
+            };
+        }
+    },
+    addListener(worker) {
+        if (!worker)
+            return false;
+        if (worker._emnapiTSFNListener)
+            return true;
+        const handler = function (e) {
+            const data = ENVIRONMENT_IS_NODE ? e : e.data;
+            const __emnapi__ = data.__emnapi__;
+            if (__emnapi__) {
+                const type = __emnapi__.type;
+                const payload = __emnapi__.payload;
+                if (type === 'tsfn-send') {
+                    const pendng = payload.tsfn + emnapiTSFN.offset.async_pending;
+                    if (Atomics.load(new Int32Array(wasmMemory.buffer), pendng >>> 2) !== 0) {
+                        emnapiTSFN.enqueue(payload.tsfn);
+                    }
+                }
+            }
+        };
+        const dispose = function () {
+            if (ENVIRONMENT_IS_NODE) {
+                worker.off('message', handler);
+            }
+            else {
+                worker.removeEventListener('message', handler, false);
+            }
+            delete worker._emnapiTSFNListener;
+        };
+        worker._emnapiTSFNListener = { handler, dispose };
+        if (ENVIRONMENT_IS_NODE) {
+            worker.on('message', handler);
+        }
+        else {
+            worker.addEventListener('message', handler, false);
+        }
+        return true;
+    },
+    initQueue(func) {
+        const size = 2 * {{{ POINTER_SIZE }}};
+        let queue = _malloc({{{ to64('size') }}});
+        if (!queue)
+            return false;
+        {{{ from64('queue') }}};
+        new Uint8Array(wasmMemory.buffer, queue, size).fill(0);
+        emnapiTSFN.storeSizeTypeValue(func + emnapiTSFN.offset.queue, queue, false);
+        return true;
+    },
+    destroyQueue(func) {
+        const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
+        if (queue) {
+            let node = emnapiTSFN.loadSizeTypeValue(queue, false);
+            while (node !== 0) {
+                const next = emnapiTSFN.loadSizeTypeValue(node + {{{ POINTER_SIZE }}}, false);
+                _free({{{ to64('node') }}});
+                node = next;
+            }
+            _free({{{ to64('queue') }}});
+        }
+    },
+    pushQueue(func, data) {
+        const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
+        const head = emnapiTSFN.loadSizeTypeValue(queue, false);
+        const tail = emnapiTSFN.loadSizeTypeValue(queue + {{{ POINTER_SIZE }}}, false);
+        const size = 2 * {{{ POINTER_SIZE }}};
+        let node = _malloc({{{ to64('size') }}});
+        if (!node)
+            throw new Error('OOM');
+        {{{ from64('node') }}};
+        emnapiTSFN.storeSizeTypeValue(node, data, false);
+        emnapiTSFN.storeSizeTypeValue(node + {{{ POINTER_SIZE }}}, 0, false);
+        if (head === 0 && tail === 0) {
+            emnapiTSFN.storeSizeTypeValue(queue, node, false);
+            emnapiTSFN.storeSizeTypeValue(queue + {{{ POINTER_SIZE }}}, node, false);
+        }
+        else {
+            emnapiTSFN.storeSizeTypeValue(tail + {{{ POINTER_SIZE }}}, node, false);
+            emnapiTSFN.storeSizeTypeValue(queue + {{{ POINTER_SIZE }}}, node, false);
+        }
+        emnapiTSFN.addQueueSize(func);
+    },
+    shiftQueue(func) {
+        const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);
+        const head = emnapiTSFN.loadSizeTypeValue(queue, false);
+        if (head === 0)
+            return 0;
+        const node = head;
+        const next = emnapiTSFN.loadSizeTypeValue(head + {{{ POINTER_SIZE }}}, false);
+        emnapiTSFN.storeSizeTypeValue(queue, next, false);
+        if (next === 0) {
+            emnapiTSFN.storeSizeTypeValue(queue + {{{ POINTER_SIZE }}}, 0, false);
+        }
+        emnapiTSFN.storeSizeTypeValue(node + {{{ POINTER_SIZE }}}, 0, false);
+        const value = emnapiTSFN.loadSizeTypeValue(node, false);
+        _free({{{ to64('node') }}});
+        emnapiTSFN.subQueueSize(func);
+        return value;
+    },
+    push(func, data, mode) {
+        const mutex = emnapiTSFN.getMutex(func);
+        const cond = emnapiTSFN.getCond(func);
+        const waitCondition = () => {
+            const queueSize = emnapiTSFN.getQueueSize(func);
+            const maxSize = emnapiTSFN.getMaxQueueSize(func);
+            return queueSize >= maxSize && maxSize > 0 && emnapiTSFN.getState(func) === 0 /* State.kOpen */;
+        };
+        const isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE;
+        let shouldDelete = false;
+        const ret = mutex.execute(() => {
+            while (waitCondition()) {
+                if (mode === 0 /* napi_threadsafe_function_call_mode.napi_tsfn_nonblocking */) {
+                    return 15 /* napi_status.napi_queue_full */;
+                }
+                /**
+                 * Browser JS main thread can not use `Atomics.wait`
+                 *
+                 * Related:
+                 * https://github.com/nodejs/node/pull/32689
+                 * https://github.com/nodejs/node/pull/33453
+                 */
+                if (isBrowserMain) {
+                    return 21 /* napi_status.napi_would_deadlock */;
+                }
+                cond.wait();
+            }
+            if (emnapiTSFN.getState(func) === 0 /* State.kOpen */) {
+                emnapiTSFN.pushQueue(func, data);
+                emnapiTSFN.send(func);
+                return 0 /* napi_status.napi_ok */;
+            }
+            if (emnapiTSFN.getThreadCount(func) === 0) {
+                return 1 /* napi_status.napi_invalid_arg */;
+            }
+            emnapiTSFN.subThreadCount(func);
+            if (!(emnapiTSFN.getState(func) === 2 /* State.kClosed */ && emnapiTSFN.getThreadCount(func) === 0)) {
+                return 16 /* napi_status.napi_closing */;
+            }
+            shouldDelete = true;
+            return 16 /* napi_status.napi_closing */;
+        });
+        if (shouldDelete) {
+            emnapiTSFN.destroy(func);
+        }
+        return ret;
+    },
+    getMutex(func) {
+        const index = func + emnapiTSFN.offset.mutex;
+        const mutex = {
+            lock() {
+                const isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE;
+                const i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                if (isBrowserMain) {
+                    while (true) {
+                        const oldValue = Atomics.compareExchange(i32a, 0, 0, 10);
+                        if (oldValue === 0) {
+                            return;
+                        }
+                    }
+                }
+                else {
+                    while (true) {
+                        const oldValue = Atomics.compareExchange(i32a, 0, 0, 10);
+                        if (oldValue === 0) {
+                            return;
+                        }
+                        Atomics.wait(i32a, 0, 10);
+                    }
+                }
+            },
+            /* lockAsync () {
+              return new Promise<void>(resolve => {
+                const again = (): void => { fn() }
+                const fn = (): void => {
+                  const i32a = new Int32Array(wasmMemory.buffer, index, 1)
+                  const oldValue = Atomics.compareExchange(i32a, 0, 0, 10)
+                  if (oldValue === 0) {
+                    resolve()
+                    return
+                  }
+                  (Atomics as any).waitAsync(i32a, 0, 10).value.then(again)
+                }
+                fn()
+              })
+            }, */
+            unlock() {
+                const i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                const oldValue = Atomics.compareExchange(i32a, 0, 10, 0);
+                if (oldValue !== 10) {
+                    throw new Error('Tried to unlock while not holding the mutex');
+                }
+                Atomics.notify(i32a, 0, 1);
+            },
+            execute(fn) {
+                mutex.lock();
+                try {
+                    return fn();
+                }
+                finally {
+                    mutex.unlock();
+                }
+            } /* ,
+            executeAsync<T> (fn: () => Promise<T>): Promise<T> {
+              return mutex.lockAsync().then(() => {
+                const r = fn()
+                mutex.unlock()
+                return r
+              }, (err) => {
+                mutex.unlock()
+                throw err
+              })
+            } */
+        };
+        return mutex;
+    },
+    getCond(func) {
+        const index = func + emnapiTSFN.offset.cond;
+        const mutex = emnapiTSFN.getMutex(func);
+        const cond = {
+            wait() {
+                const i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                const value = Atomics.load(i32a, 0);
+                mutex.unlock();
+                Atomics.wait(i32a, 0, value);
+                mutex.lock();
+            },
+            /* waitAsync () {
+              const i32a = new Int32Array(wasmMemory.buffer, index, 1)
+              const value = Atomics.load(i32a, 0)
+              mutex.unlock()
+              const lock = (): Promise<void> => mutex.lockAsync()
+              try {
+                return (Atomics as any).waitAsync(i32a, 0, value).value.then(lock, lock)
+              } catch (err) {
+                return lock()
+              }
+            }, */
+            signal() {
+                const i32a = new Int32Array(wasmMemory.buffer, index, 1);
+                Atomics.add(i32a, 0, 1);
+                Atomics.notify(i32a, 0, 1);
+            }
+        };
+        return cond;
+    },
+    getQueueSize(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue_size, true);
+    },
+    addQueueSize(func) {
+        const offset = emnapiTSFN.offset.queue_size;
+        let arr, index;
+#if MEMORY64
+        arr = new BigUint64Array(wasmMemory.buffer);
+        index = (func + offset) >>> 3;
+#else
+        arr = new Uint32Array(wasmMemory.buffer);
+        index = (func + offset) >>> 2;
+#endif
+        Atomics.add(arr, index, {{{ to64('1') }}});
+    },
+    subQueueSize(func) {
+        const offset = emnapiTSFN.offset.queue_size;
+        let arr, index;
+#if MEMORY64
+        arr = new BigUint64Array(wasmMemory.buffer);
+        index = (func + offset) >>> 3;
+#else
+        arr = new Uint32Array(wasmMemory.buffer);
+        index = (func + offset) >>> 2;
+#endif
+        Atomics.sub(arr, index, {{{ to64('1') }}});
+    },
+    getThreadCount(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.thread_count, true);
+    },
+    addThreadCount(func) {
+        const offset = emnapiTSFN.offset.thread_count;
+        let arr, index;
+#if MEMORY64
+        arr = new BigUint64Array(wasmMemory.buffer);
+        index = (func + offset) >>> 3;
+#else
+        arr = new Uint32Array(wasmMemory.buffer);
+        index = (func + offset) >>> 2;
+#endif
+        Atomics.add(arr, index, {{{ to64('1') }}});
+    },
+    subThreadCount(func) {
+        const offset = emnapiTSFN.offset.thread_count;
+        let arr, index;
+#if MEMORY64
+        arr = new BigUint64Array(wasmMemory.buffer);
+        index = (func + offset) >>> 3;
+#else
+        arr = new Uint32Array(wasmMemory.buffer);
+        index = (func + offset) >>> 2;
+#endif
+        Atomics.sub(arr, index, {{{ to64('1') }}});
+    },
+    getState(func) {
+        return Atomics.load(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.state) >>> 2);
+    },
+    setState(func, value) {
+        Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.state) >>> 2, value);
+    },
+    getHandlesClosing(func) {
+        return Atomics.load(new Int8Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing));
+    },
+    setHandlesClosing(func, value) {
+        Atomics.store(new Int8Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing), value);
+    },
+    getDispatchState(func) {
+        return Atomics.load(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >>> 2);
+    },
+    getContext(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.context, false);
+    },
+    getMaxQueueSize(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.max_queue_size, true);
+    },
+    getEnv(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.env, false);
+    },
+    getCallJSCb(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.call_js_cb, false);
+    },
+    getRef(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.ref, false);
+    },
+    getResource(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.resource, false);
+    },
+    getFinalizeCb(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_cb, false);
+    },
+    getFinalizeData(func) {
+        return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_data, false);
+    },
+    loadSizeTypeValue(offset, unsigned) {
+        let ret;
+        let arr;
+        if (unsigned) {
+#if MEMORY64
+            arr = new BigUint64Array(wasmMemory.buffer);
+            ret = Number(Atomics.load(arr, offset >>> 3));
+#else
+            arr = new Uint32Array(wasmMemory.buffer);
+            ret = Atomics.load(arr, offset >>> 2);
+#endif
+            return ret;
+        }
+        else {
+#if MEMORY64
+            arr = new BigInt64Array(wasmMemory.buffer);
+            ret = Number(Atomics.load(arr, offset >>> 3));
+#else
+            arr = new Int32Array(wasmMemory.buffer);
+            ret = Atomics.load(arr, offset >>> 2);
+#endif
+            return ret;
+        }
+    },
+    storeSizeTypeValue(offset, value, unsigned) {
+        let arr;
+        if (unsigned) {
+#if MEMORY64
+            arr = new BigUint64Array(wasmMemory.buffer);
+            Atomics.store(arr, offset >>> 3, BigInt(value));
+#else
+            arr = new Uint32Array(wasmMemory.buffer);
+            Atomics.store(arr, offset >>> 2, value);
+#endif
+            return undefined;
+        }
+        else {
+#if MEMORY64
+            arr = new BigInt64Array(wasmMemory.buffer);
+            Atomics.store(arr, offset >>> 3, BigInt(value >>> 0));
+#else
+            arr = new Int32Array(wasmMemory.buffer);
+            Atomics.store(arr, offset >>> 2, value >>> 0);
+#endif
+            return undefined;
+        }
+    },
+    releaseResources(func) {
+        if (emnapiTSFN.getState(func) !== 2 /* State.kClosed */) {
+            emnapiTSFN.setState(func, 2 /* State.kClosed */);
+            const env = emnapiTSFN.getEnv(func);
+            const envObject = emnapiEnv;
+            const ref = emnapiTSFN.getRef(func);
+            if (ref) {
+                emnapiCtx.getRef(ref).dispose();
+            }
+            const resource = emnapiTSFN.getResource(func);
+            emnapiCtx.getRef(resource).dispose();
+            {{{ makeSetValue('func', 'emnapiTSFN.offset.is_some', '0', 'i8') }}};
+            emnapiCtx.removeCleanupHook(envObject, emnapiTSFN.cleanup, func);
+            envObject.unref();
+            const asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >>> 2;
+            const arr = new Uint32Array(wasmMemory.buffer);
+            if (Atomics.load(arr, asyncRefOffset) > 0) {
+                Atomics.store(arr, asyncRefOffset, 0);
+                __emnapi_runtime_keepalive_pop();
+                emnapiCtx.decreaseWaitingRequestCounter();
+            }
+            if (emnapiNodeBinding) {
+                const view = new DataView(wasmMemory.buffer);
+                const asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);
+                const triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);
+                __emnapi_node_emit_async_destroy(asyncId, triggerAsyncId);
+            }
+        }
+    },
+    destroy(func) {
+        emnapiTSFN._liveSet.delete(func);
+        emnapiTSFN.destroyQueue(func);
+        emnapiTSFN.releaseResources(func);
+        _free({{{ to64('func') }}});
+    },
+    emptyQueue(func) {
+        const drainQueue = [];
+        emnapiTSFN.getMutex(func).execute(() => {
+            while (emnapiTSFN.getQueueSize(func) > 0) {
+                drainQueue.push(emnapiTSFN.shiftQueue(func));
+            }
+        });
+        const callJsCb = emnapiTSFN.getCallJSCb(func);
+        const context = emnapiTSFN.getContext(func);
+        let data;
+        for (let i = 0; i < drainQueue.length; i++) {
+            data = drainQueue[i];
+            if (callJsCb) {
+                {{{ makeDynCall('vpppp', 'callJsCb') }}}({{{ to64('0') }}}, {{{ to64('0') }}}, {{{ to64('context') }}}, {{{ to64('data') }}});
+            }
+        }
+    },
+    maybeDelete(func) {
+        let shouldDelete = false;
+        emnapiTSFN.getMutex(func).execute(() => {
+            if (emnapiTSFN.getThreadCount(func) > 0) {
+                emnapiTSFN.releaseResources(func);
+            }
+            else {
+                shouldDelete = true;
+            }
+        });
+        if (shouldDelete) {
+            emnapiTSFN.destroy(func);
+        }
+    },
+    finalize(func) {
+        const env = emnapiTSFN.getEnv(func);
+        const envObject = emnapiEnv;
+        emnapiCtx.openScope(envObject);
+        const finalize = emnapiTSFN.getFinalizeCb(func);
+        const data = emnapiTSFN.getFinalizeData(func);
+        const context = emnapiTSFN.getContext(func);
+        const f = () => {
+            envObject.callFinalizerInternal(0, {{{ to64('finalize') }}}, {{{ to64('data') }}}, {{{ to64('context') }}});
+        };
+        try {
+            emnapiTSFN.emptyQueue(func);
+            if (finalize) {
+                if (emnapiNodeBinding) {
+                    const resource = emnapiTSFN.getResource(func);
+                    const resource_value = emnapiCtx.getRef(resource).get();
+                    const resourceObject = emnapiCtx.jsValueFromNapiValue(resource_value);
+                    const view = new DataView(wasmMemory.buffer);
+                    const asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);
+                    const triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);
+                    emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {
+                        asyncId,
+                        triggerAsyncId
+                    });
+                }
+                else {
+                    f();
+                }
+            }
+            emnapiTSFN.maybeDelete(func);
+        }
+        finally {
+            emnapiCtx.closeScope(envObject);
+        }
+    },
+    cleanup(func) {
+        emnapiTSFN.closeHandlesAndMaybeDelete(func, 1);
+    },
+    closeHandlesAndMaybeDelete(func, set_closing) {
+        const env = emnapiTSFN.getEnv(func);
+        const envObject = emnapiEnv;
+        emnapiCtx.openScope(envObject);
+        try {
+            if (set_closing) {
+                emnapiTSFN.getMutex(func).execute(() => {
+                    emnapiTSFN.setState(func, 1 /* State.kClosing */);
+                    if (emnapiTSFN.getMaxQueueSize(func) > 0) {
+                        emnapiTSFN.getCond(func).signal();
+                    }
+                });
+            }
+            if (emnapiTSFN.getHandlesClosing(func)) {
+                return;
+            }
+            emnapiTSFN.setHandlesClosing(func, 1);
+            Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.async_pending) >>> 2, 1);
+            emnapiCtx.features.setImmediate(() => {
+                emnapiTSFN.finalize(func);
+            });
+        }
+        finally {
+            emnapiCtx.closeScope(envObject);
+        }
+    },
+    dispatchOne(func) {
+        let data = 0;
+        let popped_value = false;
+        let has_more = false;
+        const mutex = emnapiTSFN.getMutex(func);
+        const cond = emnapiTSFN.getCond(func);
+        mutex.execute(() => {
+            if (emnapiTSFN.getState(func) === 0 /* State.kOpen */) {
+                let size = emnapiTSFN.getQueueSize(func);
+                if (size > 0) {
+                    data = emnapiTSFN.shiftQueue(func);
+                    popped_value = true;
+                    const maxQueueSize = emnapiTSFN.getMaxQueueSize(func);
+                    if (size === maxQueueSize && maxQueueSize > 0) {
+                        cond.signal();
+                    }
+                    size--;
+                }
+                if (size === 0) {
+                    if (emnapiTSFN.getThreadCount(func) === 0) {
+                        emnapiTSFN.setState(func, 1 /* State.kClosing */);
+                        if (emnapiTSFN.getMaxQueueSize(func) > 0) {
+                            cond.signal();
+                        }
+                        emnapiTSFN.closeHandlesAndMaybeDelete(func, 0);
+                    }
+                }
+                else {
+                    has_more = true;
+                }
+            }
+            else {
+                emnapiTSFN.closeHandlesAndMaybeDelete(func, 0);
+            }
+        });
+        if (popped_value) {
+            const env = emnapiTSFN.getEnv(func);
+            const envObject = emnapiEnv;
+            emnapiCtx.openScope(envObject);
+            const f = () => {
+                envObject.callbackIntoModule(false, () => {
+                    const callJsCb = emnapiTSFN.getCallJSCb(func);
+                    const ref = emnapiTSFN.getRef(func);
+                    const js_callback = ref ? emnapiCtx.getRef(ref).get() : 0;
+                    if (callJsCb) {
+                        const context = emnapiTSFN.getContext(func);
+                        {{{ makeDynCall('vpppp', 'callJsCb') }}}({{{ to64('env') }}}, {{{ to64('js_callback') }}}, {{{ to64('context') }}}, {{{ to64('data') }}});
+                    }
+                    else {
+                        const jsCallback = js_callback ? emnapiCtx.jsValueFromNapiValue(js_callback) : null;
+                        if (typeof jsCallback === 'function') {
+                            jsCallback();
+                        }
+                    }
+                });
+            };
+            try {
+                if (emnapiNodeBinding) {
+                    const resource = emnapiTSFN.getResource(func);
+                    const resource_value = emnapiCtx.getRef(resource).get();
+                    const resourceObject = emnapiCtx.jsValueFromNapiValue(resource_value);
+                    const view = new DataView(wasmMemory.buffer);
+                    emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {
+                        asyncId: view.getFloat64(func + emnapiTSFN.offset.async_id, true),
+                        triggerAsyncId: view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true)
+                    });
+                }
+                else {
+                    f();
+                }
+            }
+            finally {
+                emnapiCtx.closeScope(envObject);
+            }
+        }
+        return has_more;
+    },
+    dispatch(func) {
+        let has_more = true;
+        let iterations_left = 1000;
+        const ui32a = new Uint32Array(wasmMemory.buffer);
+        const index = (func + emnapiTSFN.offset.dispatch_state) >>> 2;
+        while (has_more && --iterations_left !== 0) {
+            Atomics.store(ui32a, index, 1);
+            has_more = emnapiTSFN.dispatchOne(func);
+            if (Atomics.exchange(ui32a, index, 0) !== 1) {
+                has_more = true;
+            }
+        }
+        if (has_more) {
+            emnapiTSFN.send(func);
+        }
+    },
+    enqueue(func) {
+        // `pending` means a worker thread has requested a wakeup that has not
+        // been drained on the main thread yet.
+        const 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.
+        const scheduled = func + emnapiTSFN.offset.async_u_fd;
+        const i32a = new Int32Array(wasmMemory.buffer);
+        if (Atomics.exchange(i32a, scheduled >>> 2, 1) !== 0) {
+            return;
+        }
+        // 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.features.setImmediate(() => {
+            if (!emnapiTSFN._liveSet.has(func)) {
+                return;
+            }
+            if (Atomics.load(i32a, pending >>> 2) === 0) {
+                Atomics.store(i32a, scheduled >>> 2, 0);
+                return;
+            }
+            emnapiCtx.features.setImmediate(() => {
+                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(func) {
+        const current_state = Atomics.or(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >>> 2, 1 << 1);
+        if ((current_state & 1) === 1) {
+            return;
+        }
+        const 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);
+            }
+        }
+    }
+};
+emnapiTSFN.init();
+emnapiPluginCtx.emnapiTSFN = emnapiTSFN;
+/**
+ * @__deps _emnapi_node_emit_async_init
+ * @__deps _emnapi_runtime_keepalive_push
+ * @__sig ippppppppppp
+ */
+function _napi_create_threadsafe_function(env, func, async_resource, async_resource_name, max_queue_size, initial_thread_count, thread_finalize_data, thread_finalize_cb, context, call_js_cb, result) {
+    if (!env)
+        return 1 /* napi_status.napi_invalid_arg */;
+    // @ts-expect-error
+    const envObject = emnapiEnv;
+    envObject.checkGCAccess();
+    if (!async_resource_name)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    {{{ from64('max_queue_size') }}};
+    {{{ from64('initial_thread_count') }}};
+    {{{ from64('env') }}};
+    {{{ from64('thread_finalize_data') }}};
+    {{{ from64('thread_finalize_cb') }}};
+    {{{ from64('context') }}};
+    {{{ from64('call_js_cb') }}};
+    max_queue_size = max_queue_size >>> 0;
+    initial_thread_count = initial_thread_count >>> 0;
+    if (initial_thread_count === 0) {
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    }
+    if (!result)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    let ref = 0;
+    {{{ from64('func') }}};
+    if (!func) {
+        if (!call_js_cb)
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    }
+    else {
+        const funcValue = emnapiCtx.jsValueFromNapiValue(func);
+        if (typeof funcValue !== 'function') {
+            return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+        }
+        ref = emnapiCtx.createReference(envObject, func, 1, 1 /* ReferenceOwnership.kUserland */).id;
+    }
+    let asyncResourceObject;
+    if (async_resource) {
+        asyncResourceObject = emnapiCtx.jsValueFromNapiValue(async_resource);
+        if (asyncResourceObject == null) {
+            return envObject.setLastError(2 /* napi_status.napi_object_expected */);
+        }
+        asyncResourceObject = Object(asyncResourceObject);
+    }
+    else {
+        asyncResourceObject = {};
+    }
+    const resource = emnapiCtx.napiValueFromJsValue(asyncResourceObject);
+    let asyncResourceName = emnapiCtx.jsValueFromNapiValue(async_resource_name);
+    if (typeof asyncResourceName === 'symbol') {
+        return envObject.setLastError(3 /* napi_status.napi_string_expected */);
+    }
+    asyncResourceName = String(asyncResourceName);
+    const resource_name = emnapiCtx.napiValueFromJsValue(asyncResourceName);
+    // tsfn create
+    const sizeofTSFN = emnapiTSFN.offset.__size__;
+    let tsfn = _malloc({{{ to64('sizeofTSFN') }}});
+    if (!tsfn)
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
+    {{{ from64('tsfn') }}};
+    new Uint8Array(wasmMemory.buffer).subarray(tsfn, tsfn + sizeofTSFN).fill(0);
+    const resourceRef = emnapiCtx.createReference(envObject, resource, 1, 1 /* ReferenceOwnership.kUserland */);
+    const resource_ = resourceRef.id;
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.resource', 'resource_', '*') }}};
+    if (!emnapiTSFN.initQueue(tsfn)) {
+        _free({{{ to64('tsfn') }}});
+        resourceRef.dispose();
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
+    }
+    __emnapi_node_emit_async_init(resource, resource_name, -1, tsfn + emnapiTSFN.offset.async_id);
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.is_some', '1', 'i8') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.thread_count', 'initial_thread_count', SIZE_TYPE) }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.context', 'context', '*') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.max_queue_size', 'max_queue_size', SIZE_TYPE) }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.ref', 'ref', '*') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.env', 'env', '*') }}};
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.finalize_data', 'thread_finalize_data', '*') }}};
+    {{{ 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();
+    {{{ makeSetValue('tsfn', 'emnapiTSFN.offset.async_ref', '1', 'u32') }}};
+    {{{ from64('result') }}};
+    {{{ makeSetValue('result', 0, 'tsfn', '*') }}};
+    return envObject.clearLastError();
+}
+/** @__sig ipp */
+function _napi_get_threadsafe_function_context(func, result) {
+    if (!func || !result) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    {{{ from64('result') }}};
+    const context = emnapiTSFN.getContext(func);
+    {{{ makeSetValue('result', 0, 'context', '*') }}};
+    return 0 /* napi_status.napi_ok */;
+}
+/** @__sig ippi */
+function _napi_call_threadsafe_function(func, data, mode) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    {{{ from64('data') }}};
+    return emnapiTSFN.push(func, data, mode);
+}
+/** @__sig ip */
+function _napi_acquire_threadsafe_function(func) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    const mutex = emnapiTSFN.getMutex(func);
+    return mutex.execute(() => {
+        if (emnapiTSFN.getState(func) === 0 /* State.kOpen */) {
+            emnapiTSFN.addThreadCount(func);
+            return 0 /* napi_status.napi_ok */;
+        }
+        return 16 /* napi_status.napi_closing */;
+    });
+}
+/** @__sig ipi */
+function _napi_release_threadsafe_function(func, mode) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    const mutex = emnapiTSFN.getMutex(func);
+    const cond = emnapiTSFN.getCond(func);
+    let shouldDelete = false;
+    const ret = mutex.execute(() => {
+        if (emnapiTSFN.getThreadCount(func) === 0) {
+            return 1 /* napi_status.napi_invalid_arg */;
+        }
+        emnapiTSFN.subThreadCount(func);
+        if (emnapiTSFN.getThreadCount(func) === 0 || mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) {
+            if (emnapiTSFN.getState(func) === 0 /* State.kOpen */) {
+                if (mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) {
+                    emnapiTSFN.setState(func, 1 /* State.kClosing */);
+                }
+                if (emnapiTSFN.getState(func) === 1 /* State.kClosing */ && emnapiTSFN.getMaxQueueSize(func) > 0) {
+                    cond.signal();
+                }
+                emnapiTSFN.send(func);
+            }
+        }
+        if (!(emnapiTSFN.getState(func) === 2 /* State.kClosed */ && emnapiTSFN.getThreadCount(func) === 0)) {
+            return 0 /* napi_status.napi_ok */;
+        }
+        shouldDelete = true;
+        return 0 /* napi_status.napi_ok */;
+    });
+    if (shouldDelete) {
+        emnapiTSFN.destroy(func);
+    }
+    return ret;
+}
+/**
+ * @__deps _emnapi_runtime_keepalive_pop
+ * @__sig ipp
+ */
+function _napi_unref_threadsafe_function(env, func) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    const asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >>> 2;
+    const arr = new Uint32Array(wasmMemory.buffer);
+    const currentValue = Atomics.load(arr, asyncRefOffset);
+    if (currentValue > 0) {
+        Atomics.store(arr, asyncRefOffset, currentValue - 1);
+        if (currentValue === 1) {
+            __emnapi_runtime_keepalive_pop();
+            emnapiCtx.decreaseWaitingRequestCounter();
+        }
+    }
+    return 0 /* napi_status.napi_ok */;
+}
+/**
+ * @__deps _emnapi_runtime_keepalive_push
+ * @__sig ipp
+ */
+function _napi_ref_threadsafe_function(env, func) {
+    if (!func) {
+        abort();
+        return 1 /* napi_status.napi_invalid_arg */;
+    }
+    {{{ from64('func') }}};
+    const asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >>> 2;
+    const arr = new Uint32Array(wasmMemory.buffer);
+    const currentValue = Atomics.load(arr, asyncRefOffset);
+    if (!currentValue) {
+        __emnapi_runtime_keepalive_push();
+        emnapiCtx.increaseWaitingRequestCounter();
+    }
+    Atomics.store(arr, asyncRefOffset, currentValue + 1);
+    return 0 /* napi_status.napi_ok */;
+}
+(typeof addToLibrary === "function" ? addToLibrary : (...args) => mergeInto(LibraryManager.library, ...args))({
+    $emnapiEnv: "undefined",
+    $emnapiTSFN: emnapiTSFN,
+    $emnapiTSFN__deps: ["$emnapiEnv", "malloc", "free", "$emnapiCtx", "$emnapiEnv", "$emnapiNodeBinding", "_emnapi_node_emit_async_destroy", "_emnapi_runtime_keepalive_pop"],
+    $emnapiTSFN__postset: "emnapiTSFN.init();",
+    napi_acquire_threadsafe_function: _napi_acquire_threadsafe_function,
+    napi_acquire_threadsafe_function__deps: ["$emnapiTSFN"],
+    napi_acquire_threadsafe_function__sig: "ip",
+    napi_call_threadsafe_function: _napi_call_threadsafe_function,
+    napi_call_threadsafe_function__deps: ["$emnapiTSFN"],
+    napi_call_threadsafe_function__sig: "ippi",
+    napi_create_threadsafe_function: _napi_create_threadsafe_function,
+    napi_create_threadsafe_function__deps: ["$emnapiEnv", "$emnapiTSFN", "_emnapi_node_emit_async_init", "_emnapi_runtime_keepalive_push"],
+    napi_create_threadsafe_function__sig: "ippppppppppp",
+    napi_get_threadsafe_function_context: _napi_get_threadsafe_function_context,
+    napi_get_threadsafe_function_context__deps: ["$emnapiTSFN"],
+    napi_get_threadsafe_function_context__sig: "ipp",
+    napi_ref_threadsafe_function: _napi_ref_threadsafe_function,
+    napi_ref_threadsafe_function__deps: ["$emnapiTSFN", "_emnapi_runtime_keepalive_push"],
+    napi_ref_threadsafe_function__sig: "ipp",
+    napi_release_threadsafe_function: _napi_release_threadsafe_function,
+    napi_release_threadsafe_function__deps: ["$emnapiTSFN"],
+    napi_release_threadsafe_function__sig: "ipi",
+    napi_unref_threadsafe_function: _napi_unref_threadsafe_function,
+    napi_unref_threadsafe_function__deps: ["$emnapiTSFN", "_emnapi_runtime_keepalive_pop"],
+    napi_unref_threadsafe_function__sig: "ipp"
+});