@napi-rs/cli 3.10.0 → 3.10.2

package/src/api/__tests__/__snapshots__/templates.spec.ts.md

@@ -101,6 +101,35 @@ Generated by [AVA](https://avajs.dev).
     ␊
     const __wasiDisposeSymbol = Symbol.for('napi.rs.wasi.dispose')␊
     const __wasiWorkers = new Set()␊
+    // The thread manager has to be reachable *before* anything that can throw␊
+    // during load or registration. Initialization can fail after the pool has␊
+    // already spawned workers, and the rollback still has to mark their␊
+    // terminations as expected — but \`__napiModule\` is assigned only when␊
+    // instantiation RETURNS, so on exactly that path it is still undefined. A␊
+    // plugin factory runs while the emnapi module is being created, before the␊
+    // wasm is loaded and before any registration function runs, and its context␊
+    // carries the very same manager instance.␊
+    let __wasiThreadManager␊
+    ␊
+    function __captureWasiThreadManager(context) {␊
+      if (context && context.PThread) {␊
+        __wasiThreadManager = context.PThread␊
+      }␊
+      return {}␊
+    }␊
+    ␊
+    function __getWasiThreadManager() {␊
+      const manager =␊
+        __wasiThreadManager !== undefined␊
+          ? __wasiThreadManager␊
+          : __napiModule␊
+            ? __napiModule.PThread␊
+            : undefined␊
+      if (manager && typeof manager.terminateWorker === 'function') {␊
+        return manager␊
+      }␊
+      return undefined␊
+    }␊
     let __napiInstance␊
     let __emnapiContextDestroyed = false␊
     let __emnapiContextDestroyPromise␊
@@ -110,6 +139,7 @@ Generated by [AVA](https://avajs.dev).
     let __emnapiWasmEnvCleanupDrained = false␊
     let __emnapiWasmEnvCleanupDrainPromise␊
     let __wasiDisposed = false␊
+    let __wasiAsyncWorkDrainPromise␊
     let __wasiDisposePromise␊
     let __completeWasiDisposal = function () {}␊
     // Overridden by loader flavors that have a last-resort reclaim for a rollback␊
@@ -267,6 +297,24 @@ Generated by [AVA](https://avajs.dev).
       }␊
     })()␊
     ␊
+    // A real, *referenced* timer, for waits that must let the whole host make␊
+    // progress between looks — the async-work drain polls the addon rather than␊
+    // interleaving with the @emnapi/core dispatch, so a zero-delay macrotask there␊
+    // would spin the loop instead of yielding it. Falls back to the macrotask␊
+    // scheduler on a host without timers.␊
+    function __scheduleTimer(callback, delay) {␊
+      const setTimer = globalThis.setTimeout␊
+      if (typeof setTimer !== 'function') {␊
+        __scheduleMacrotask(callback)␊
+        return␊
+      }␊
+      try {␊
+        setTimer(callback, delay)␊
+      } catch {␊
+        __scheduleMacrotask(callback)␊
+      }␊
+    }␊
+    ␊
     // Turns to wait for while the addon still reports queued settlements. Reaching␊
     // zero is the only success. A counter still nonzero at this bound rejects the␊
     // disposal as retryable (\`ERR_NAPI_WASI_CLEANUP_PENDING\`) rather than␊
@@ -423,13 +471,209 @@ Generated by [AVA](https://avajs.dev).
       return destroyPromise␊
     }␊
     ␊
+    /**␊
+     * Holds the event loop open until \`work\` settles.␊
+     *␊
+     * Nothing else can: the pool workers are deliberately unreferenced so an idle␊
+     * binding cannot keep a process alive, and referencing them again for the␊
+     * termination does not hold either — emnapi unreferences a worker the moment it␊
+     * reports \`async-thread-ready\`, which for a worker that was still starting␊
+     * lands *after* the termination began. Without a handle of its own, an␊
+     * \`await dispose()\` with nothing else pending exits the process with its␊
+     * promise unsettled, and everything after the \`await\` is skipped.␊
+     *␊
+     * The timer is cleared as soon as the work settles, so this never outlives the␊
+     * disposal that asked for it.␊
+     */␊
+    function __keepEventLoopAliveUntil(work) {␊
+      const setTimer = globalThis.setInterval␊
+      const clearTimer = globalThis.clearInterval␊
+      if (typeof setTimer !== 'function' || typeof clearTimer !== 'function') {␊
+        return work␊
+      }␊
+      let timer␊
+      try {␊
+        timer = setTimer(function () {}, 50)␊
+      } catch {␊
+        return work␊
+      }␊
+      const release = function () {␊
+        try {␊
+          clearTimer(timer)␊
+        } catch {}␊
+      }␊
+      return work.then(␊
+        (value) => {␊
+          release()␊
+          return value␊
+        },␊
+        (error) => {␊
+          release()␊
+          throw error␊
+        },␊
+      )␊
+    }␊
+    ␊
+    // How often to re-read \`napi_wasm_async_work_pending\` while waiting. The wait␊
+    // ends when the addon reports zero, so this only decides how promptly disposal␊
+    // notices — not how long it waits.␊
+    const __WASI_ASYNC_WORK_POLL_INTERVAL_MS = 1␊
+    ␊
+    /**␊
+     * Settles this addon's outstanding \`napi_async_work\` before the teardown that␊
+     * would strand it.␊
+     *␊
+     * \`napi_prepare_wasm_env_cleanup\` does not cover async work, and nothing about␊
+     * it is observable from JavaScript: the threadless archive resolves␊
+     * \`napi_*_async_work\` through the \`@emnapi/core\` plugins, but the threaded one␊
+     * links the C \`async_work.c\` on the uv threadpool, so there the wasm neither␊
+     * imports nor exports those symbols and the only brackets a loader could watch␊
+     * (\`_emnapi_ctx_*_waiting_request_counter\`) are shared with threadsafe␊
+     * functions. The addon is the one place both flavors go through, so it answers␊
+     * for both, through the same kind of handshake the settlement drain uses:␊
+     *␊
+     *   - \`napi_wasm_cancel_pending_async_work()\` cancels what no thread has␊
+     *     started. Those completion callbacks run with \`napi_cancelled\`, which␊
+     *     napi-rs turns into a promise rejected with an \`AbortError\`.␊
+     *   - \`napi_wasm_async_work_pending()\` counts what is still owed a completion␊
+     *     callback. Work already executing refuses cancellation and stays counted␊
+     *     until it finishes normally — which it can, because this runs before the␊
+     *     barrier, before \`Context.destroy()\` and before anything is terminated.␊
+     *␊
+     * Both exports are optional: an addon built against a napi crate that predates␊
+     * them drains nothing and keeps the previous behavior, exactly as the␊
+     * \`napi_wasm_env_cleanup_pending\` handshake degrades.␊
+     *␊
+     * Returns nothing when there is nothing outstanding, which keeps disposal␊
+     * synchronous in the common case. The promise it returns otherwise never␊
+     * rejects.␊
+     *␊
+     * The wait has no deadline, and that is the point: giving up would destroy the␊
+     * environment with a completion callback still owed, which is the stranding␊
+     * this exists to prevent. A task whose \`execute\` never returns already keeps an␊
+     * *undisposed* process alive in exactly the same way, so disposal inherits that␊
+     * rather than inventing a bound it cannot honor.␊
+     *␊
+     * Safe to call from inside a completion callback, which is reachable: settling␊
+     * a task runs addon code that can re-enter JavaScript — a setter on the value␊
+     * being handed back, a threadsafe-function callback — and that JavaScript can␊
+     * call \`dispose()\`. Two things make it terminate rather than wait on itself:␊
+     *␊
+     *   - The addon keeps a work registered until its completion callback␊
+     *     *finishes*, so the count read here is at least one and this takes the␊
+     *     polling path instead of declaring the environment drained and tearing it␊
+     *     down from inside the frame that is still settling a promise.␊
+     *   - The poll is a timer, so it cannot run until the callback has returned to␊
+     *     the host — by which time that work has left the registry. The count the␊
+     *     next poll reads is the one taken after the callback finished.␊
+     *␊
+     * \`__disposeWasiBinding\` hands every caller the same in-flight promise, so the␊
+     * nested call joins this disposal rather than starting a second one.␊
+     */␊
+    function __drainWasiAsyncWork() {␊
+      if (__wasiAsyncWorkDrainPromise !== undefined) {␊
+        return __wasiAsyncWorkDrainPromise␊
+      }␊
+      const exports = __napiInstance?.exports␊
+      const pending = exports?.napi_wasm_async_work_pending␊
+      const cancelPending = exports?.napi_wasm_cancel_pending_async_work␊
+      if (typeof pending !== 'function' || typeof cancelPending !== 'function') {␊
+        return␊
+      }␊
+    ␊
+      const readPending = () => {␊
+        try {␊
+          return pending()␊
+        } catch (error) {␊
+          // A trap is the only way this call fails: it reads a counter and cannot␊
+          // allocate or call back into JavaScript. A trapped instance can no longer␊
+          // run anything, so its outstanding work is unreachable by definition —␊
+          // there is nothing left to wait for, and refusing to dispose would only␊
+          // keep a dead instance and its stuck counter alive. Best-effort here is␊
+          // the honest answer, and it is what disposal did before this drain␊
+          // existed.␊
+          //␊
+          // Only a trap. Anything else means the export is not what this loader␊
+          // thinks it is, which is a defect worth surfacing rather than disposing␊
+          // over.␊
+          if (error instanceof globalThis.WebAssembly.RuntimeError) {␊
+            return 0␊
+          }␊
+          throw error␊
+        }␊
+      }␊
+    ␊
+      if (!readPending()) {␊
+        return␊
+      }␊
+      try {␊
+        cancelPending()␊
+      } catch {␊
+        // Cancellation is an optimization: it bounds the wait by the work already␊
+        // executing. Failing it only means waiting for the whole queue instead.␊
+      }␊
+      if (!readPending()) {␊
+        return␊
+      }␊
+    ␊
+      const drainPromise = __keepEventLoopAliveUntil(␊
+        (async () => {␊
+          while (readPending()) {␊
+            await new Promise((resolve) => {␊
+              __scheduleTimer(resolve, __WASI_ASYNC_WORK_POLL_INTERVAL_MS)␊
+            })␊
+          }␊
+        })(),␊
+      ).then(␊
+        () => {␊
+          __wasiAsyncWorkDrainPromise = undefined␊
+        },␊
+        (error) => {␊
+          // A wait that could not run is not a wait that finished. The only way␊
+          // here is a host whose timers and macrotask primitives all refuse, and␊
+          // the work is still outstanding — reporting success would destroy the␊
+          // environment over it, which is the stranding this exists to prevent.␊
+          // Reject instead: disposal stays retryable, and the context is not␊
+          // destroyed. Clearing the memo first is what makes the retry re-run this.␊
+          __wasiAsyncWorkDrainPromise = undefined␊
+          throw error␊
+        },␊
+      )␊
+      __wasiAsyncWorkDrainPromise = drainPromise␊
+      return drainPromise␊
+    }␊
+    ␊
+    /**␊
+     * \`@emnapi/wasi-threads\` counts a worker exit as expected only when its own␊
+     * thread manager performed the termination. A bare \`worker.terminate()\` reaches␊
+     * the manager's \`exit\` listener instead, which reports␊
+     * \`worker (tid = N) sent an error! ... stopped with exit code 1\` and rethrows␊
+     * inside the emit — aborting the \`once('exit')\` that backs the terminate␊
+     * promise, so disposal never settles and the process dies with an uncaught␊
+     * exception. Mark the termination through the manager first.␊
+     *␊
+     * The manager comes from \`__getWasiThreadManager\`, not from \`__napiModule\`:␊
+     * the initialization rollback runs on the one path where instantiation never␊
+     * returned, so \`__napiModule\` is still undefined there while the workers it␊
+     * spawned are already registered and loaded.␊
+     *␊
+     * Not \`terminateAllThreads()\`: that one recreates the pool it just shut down.␊
+     */␊
     function __terminateWasiWorkers() {␊
       const cleanupErrors = []␊
       const pending = []␊
+      const threadManager = __getWasiThreadManager()␊
     ␊
       for (const worker of __wasiWorkers) {␊
         let result␊
         try {␊
+          if (threadManager) {␊
+            threadManager.terminateWorker(worker)␊
+            // \`terminateWorker\` leaves behind a reporter that logs every message␊
+            // still queued on the port, which Node flushes on exit. Nothing is␊
+            // listening for those any more.␊
+            worker.onmessage = undefined␊
+          }␊
           result = worker.terminate()␊
         } catch (error) {␊
           cleanupErrors.push(error)␊
@@ -459,7 +703,9 @@ Generated by [AVA](https://avajs.dev).
           )␊
         }␊
       }␊
-      return pending.length > 0 ? Promise.all(pending).then(finish) : finish()␊
+      return pending.length > 0␊
+        ? __keepEventLoopAliveUntil(Promise.all(pending)).then(finish)␊
+        : finish()␊
     }␊
     ␊
     function __finishWasiDisposal() {␊
@@ -478,7 +724,7 @@ Generated by [AVA](https://avajs.dev).
       return __finishWasiDisposal()␊
     }␊
     ␊
-    function __startWasiDisposal() {␊
+    function __cleanUpWasmEnvForWasiDisposal() {␊
       // Run the pre-teardown barrier, then let the settlements it queued actually␊
       // reach JavaScript, and only then destroy the environment. Doing these two␊
       // back to back is what strands them.␊
@@ -490,6 +736,21 @@ Generated by [AVA](https://avajs.dev).
       return __continueWasiDisposal()␊
     }␊
     ␊
+    function __startWasiDisposal() {␊
+      // Outstanding \`napi_async_work\` goes first, while the environment is still␊
+      // completely live: the completion callbacks run addon code, and everything␊
+      // after this point takes that away from them — the barrier shuts the async␊
+      // runtime down, \`Context.destroy()\` stops JavaScript calls, and terminating␊
+      // the pool threads removes what would have reported the work finished.␊
+      const asyncWorkResult = __drainWasiAsyncWork()␊
+      if (__isThenable(asyncWorkResult)) {␊
+        return Promise.resolve(asyncWorkResult).then(␊
+          __cleanUpWasmEnvForWasiDisposal,␊
+        )␊
+      }␊
+      return __cleanUpWasmEnvForWasiDisposal()␊
+    }␊
+    ␊
     /**␊
      * Disposes this generated WASI binding.␊
      *␊
@@ -631,29 +892,60 @@ Generated by [AVA](https://avajs.dev).
      * bug with no upper bound, while the retained bookkeeping is bounded by the page.␊
      */␊
     function __rollbackWasiInitialization() {␊
-      const cleanupErrors = []␊
-      let drainResult␊
-      let settlementsUnreached = false␊
+      // The environment teardown this rollback performs, kept nested so it cannot␊
+      // be reached without the async-work drain below running first.␊
+      function __rollbackWasmEnvForWasiInitialization() {␊
+        const cleanupErrors = []␊
+        let drainResult␊
+        let settlementsUnreached = false␊
+        try {␊
+          __prepareWasmEnvCleanup()␊
+          drainResult = __drainWasmEnvCleanup()␊
+        } catch (cleanupError) {␊
+          cleanupErrors.push(cleanupError)␊
+          settlementsUnreached = true␊
+        }␊
+        if (__isThenable(drainResult)) {␊
+          return Promise.resolve(drainResult).then(␊
+            () => __destroyContextForWasiRollback(cleanupErrors),␊
+            (cleanupError) => {␊
+              cleanupErrors.push(cleanupError)␊
+              return __retainFailedWasiRollback(cleanupErrors)␊
+            },␊
+          )␊
+        }␊
+        if (settlementsUnreached) {␊
+          return __retainFailedWasiRollback(cleanupErrors)␊
+        }␊
+        return __destroyContextForWasiRollback(cleanupErrors)␊
+      }␊
+    ␊
+      // Same reason as \`__startWasiDisposal\`: a module-init hook can start async␊
+      // work before the load goes on to fail, and this rollback tears down exactly␊
+      // what those completions need. Settle them while everything is still live,␊
+      // before the barrier and the teardown above take that away.␊
+      //␊
+      // A drain that could not finish leaves async work possibly outstanding, and␊
+      // destroying the context over it would strand exactly what this rollback is␊
+      // there to settle. Stop short and retain instead — the same trade␊
+      // \`__rollbackWasmEnvForWasiInitialization\` makes for the settlement drain, so␊
+      // the context stays reclaimable by a retry or by this flavor's own␊
+      // last-resort teardown.␊
+      const __retainAfterAsyncWorkDrainFailure = (cleanupError) =>␊
+        __retainFailedWasiRollback([cleanupError])␊
+      let asyncWorkResult␊
       try {␊
-        __prepareWasmEnvCleanup()␊
-        drainResult = __drainWasmEnvCleanup()␊
+        asyncWorkResult = __drainWasiAsyncWork()␊
       } catch (cleanupError) {␊
-        cleanupErrors.push(cleanupError)␊
-        settlementsUnreached = true␊
+        return __retainAfterAsyncWorkDrainFailure(cleanupError)␊
       }␊
-      if (__isThenable(drainResult)) {␊
-        return Promise.resolve(drainResult).then(␊
-          () => __destroyContextForWasiRollback(cleanupErrors),␊
-          (cleanupError) => {␊
-            cleanupErrors.push(cleanupError)␊
-            return __retainFailedWasiRollback(cleanupErrors)␊
-          },␊
+      if (__isThenable(asyncWorkResult)) {␊
+        return Promise.resolve(asyncWorkResult).then(␊
+          __rollbackWasmEnvForWasiInitialization,␊
+          __retainAfterAsyncWorkDrainFailure,␊
         )␊
       }␊
-      if (settlementsUnreached) {␊
-        return __retainFailedWasiRollback(cleanupErrors)␊
-      }␊
-      return __destroyContextForWasiRollback(cleanupErrors)␊
+      return __rollbackWasmEnvForWasiInitialization()␊
     }␊
     ␊
     let __wasiModule␊
@@ -675,7 +967,11 @@ Generated by [AVA](https://avajs.dev).
         context: __emnapiContext,␊
         asyncWorkPoolSize: __asyncWorkPoolSize,␊
         reuseWorker: { size: __asyncWorkPoolSize + __workerPoolSize },␊
-        plugins: [__emnapiAsyncWorkPlugin, __emnapiTSFNPlugin],␊
+        plugins: [␊
+          __captureWasiThreadManager,␊
+          __emnapiAsyncWorkPlugin,␊
+          __emnapiTSFNPlugin,␊
+        ],␊
         wasi: __wasi,␊
         onCreateWorker() {␊
           const worker = new Worker(new URL('./wasi-worker-browser.mjs', import.meta.url), {␊
@@ -814,6 +1110,35 @@ Generated by [AVA](https://avajs.dev).
     ␊
     const __wasiDisposeSymbol = Symbol.for('napi.rs.wasi.dispose')␊
     const __wasiWorkers = new Set()␊
+    // The thread manager has to be reachable *before* anything that can throw␊
+    // during load or registration. Initialization can fail after the pool has␊
+    // already spawned workers, and the rollback still has to mark their␊
+    // terminations as expected — but \`__napiModule\` is assigned only when␊
+    // instantiation RETURNS, so on exactly that path it is still undefined. A␊
+    // plugin factory runs while the emnapi module is being created, before the␊
+    // wasm is loaded and before any registration function runs, and its context␊
+    // carries the very same manager instance.␊
+    let __wasiThreadManager␊
+    ␊
+    function __captureWasiThreadManager(context) {␊
+      if (context && context.PThread) {␊
+        __wasiThreadManager = context.PThread␊
+      }␊
+      return {}␊
+    }␊
+    ␊
+    function __getWasiThreadManager() {␊
+      const manager =␊
+        __wasiThreadManager !== undefined␊
+          ? __wasiThreadManager␊
+          : __napiModule␊
+            ? __napiModule.PThread␊
+            : undefined␊
+      if (manager && typeof manager.terminateWorker === 'function') {␊
+        return manager␊
+      }␊
+      return undefined␊
+    }␊
     let __napiInstance␊
     let __emnapiContextDestroyed = false␊
     let __emnapiContextDestroyPromise␊
@@ -823,6 +1148,7 @@ Generated by [AVA](https://avajs.dev).
     let __emnapiWasmEnvCleanupDrained = false␊
     let __emnapiWasmEnvCleanupDrainPromise␊
     let __wasiDisposed = false␊
+    let __wasiAsyncWorkDrainPromise␊
     let __wasiDisposePromise␊
     let __completeWasiDisposal = function () {}␊
     // Overridden by loader flavors that have a last-resort reclaim for a rollback␊
@@ -980,6 +1306,24 @@ Generated by [AVA](https://avajs.dev).
       }␊
     })()␊
     ␊
+    // A real, *referenced* timer, for waits that must let the whole host make␊
+    // progress between looks — the async-work drain polls the addon rather than␊
+    // interleaving with the @emnapi/core dispatch, so a zero-delay macrotask there␊
+    // would spin the loop instead of yielding it. Falls back to the macrotask␊
+    // scheduler on a host without timers.␊
+    function __scheduleTimer(callback, delay) {␊
+      const setTimer = globalThis.setTimeout␊
+      if (typeof setTimer !== 'function') {␊
+        __scheduleMacrotask(callback)␊
+        return␊
+      }␊
+      try {␊
+        setTimer(callback, delay)␊
+      } catch {␊
+        __scheduleMacrotask(callback)␊
+      }␊
+    }␊
+    ␊
     // Turns to wait for while the addon still reports queued settlements. Reaching␊
     // zero is the only success. A counter still nonzero at this bound rejects the␊
     // disposal as retryable (\`ERR_NAPI_WASI_CLEANUP_PENDING\`) rather than␊
@@ -1136,13 +1480,209 @@ Generated by [AVA](https://avajs.dev).
       return destroyPromise␊
     }␊
     ␊
+    /**␊
+     * Holds the event loop open until \`work\` settles.␊
+     *␊
+     * Nothing else can: the pool workers are deliberately unreferenced so an idle␊
+     * binding cannot keep a process alive, and referencing them again for the␊
+     * termination does not hold either — emnapi unreferences a worker the moment it␊
+     * reports \`async-thread-ready\`, which for a worker that was still starting␊
+     * lands *after* the termination began. Without a handle of its own, an␊
+     * \`await dispose()\` with nothing else pending exits the process with its␊
+     * promise unsettled, and everything after the \`await\` is skipped.␊
+     *␊
+     * The timer is cleared as soon as the work settles, so this never outlives the␊
+     * disposal that asked for it.␊
+     */␊
+    function __keepEventLoopAliveUntil(work) {␊
+      const setTimer = globalThis.setInterval␊
+      const clearTimer = globalThis.clearInterval␊
+      if (typeof setTimer !== 'function' || typeof clearTimer !== 'function') {␊
+        return work␊
+      }␊
+      let timer␊
+      try {␊
+        timer = setTimer(function () {}, 50)␊
+      } catch {␊
+        return work␊
+      }␊
+      const release = function () {␊
+        try {␊
+          clearTimer(timer)␊
+        } catch {}␊
+      }␊
+      return work.then(␊
+        (value) => {␊
+          release()␊
+          return value␊
+        },␊
+        (error) => {␊
+          release()␊
+          throw error␊
+        },␊
+      )␊
+    }␊
+    ␊
+    // How often to re-read \`napi_wasm_async_work_pending\` while waiting. The wait␊
+    // ends when the addon reports zero, so this only decides how promptly disposal␊
+    // notices — not how long it waits.␊
+    const __WASI_ASYNC_WORK_POLL_INTERVAL_MS = 1␊
+    ␊
+    /**␊
+     * Settles this addon's outstanding \`napi_async_work\` before the teardown that␊
+     * would strand it.␊
+     *␊
+     * \`napi_prepare_wasm_env_cleanup\` does not cover async work, and nothing about␊
+     * it is observable from JavaScript: the threadless archive resolves␊
+     * \`napi_*_async_work\` through the \`@emnapi/core\` plugins, but the threaded one␊
+     * links the C \`async_work.c\` on the uv threadpool, so there the wasm neither␊
+     * imports nor exports those symbols and the only brackets a loader could watch␊
+     * (\`_emnapi_ctx_*_waiting_request_counter\`) are shared with threadsafe␊
+     * functions. The addon is the one place both flavors go through, so it answers␊
+     * for both, through the same kind of handshake the settlement drain uses:␊
+     *␊
+     *   - \`napi_wasm_cancel_pending_async_work()\` cancels what no thread has␊
+     *     started. Those completion callbacks run with \`napi_cancelled\`, which␊
+     *     napi-rs turns into a promise rejected with an \`AbortError\`.␊
+     *   - \`napi_wasm_async_work_pending()\` counts what is still owed a completion␊
+     *     callback. Work already executing refuses cancellation and stays counted␊
+     *     until it finishes normally — which it can, because this runs before the␊
+     *     barrier, before \`Context.destroy()\` and before anything is terminated.␊
+     *␊
+     * Both exports are optional: an addon built against a napi crate that predates␊
+     * them drains nothing and keeps the previous behavior, exactly as the␊
+     * \`napi_wasm_env_cleanup_pending\` handshake degrades.␊
+     *␊
+     * Returns nothing when there is nothing outstanding, which keeps disposal␊
+     * synchronous in the common case. The promise it returns otherwise never␊
+     * rejects.␊
+     *␊
+     * The wait has no deadline, and that is the point: giving up would destroy the␊
+     * environment with a completion callback still owed, which is the stranding␊
+     * this exists to prevent. A task whose \`execute\` never returns already keeps an␊
+     * *undisposed* process alive in exactly the same way, so disposal inherits that␊
+     * rather than inventing a bound it cannot honor.␊
+     *␊
+     * Safe to call from inside a completion callback, which is reachable: settling␊
+     * a task runs addon code that can re-enter JavaScript — a setter on the value␊
+     * being handed back, a threadsafe-function callback — and that JavaScript can␊
+     * call \`dispose()\`. Two things make it terminate rather than wait on itself:␊
+     *␊
+     *   - The addon keeps a work registered until its completion callback␊
+     *     *finishes*, so the count read here is at least one and this takes the␊
+     *     polling path instead of declaring the environment drained and tearing it␊
+     *     down from inside the frame that is still settling a promise.␊
+     *   - The poll is a timer, so it cannot run until the callback has returned to␊
+     *     the host — by which time that work has left the registry. The count the␊
+     *     next poll reads is the one taken after the callback finished.␊
+     *␊
+     * \`__disposeWasiBinding\` hands every caller the same in-flight promise, so the␊
+     * nested call joins this disposal rather than starting a second one.␊
+     */␊
+    function __drainWasiAsyncWork() {␊
+      if (__wasiAsyncWorkDrainPromise !== undefined) {␊
+        return __wasiAsyncWorkDrainPromise␊
+      }␊
+      const exports = __napiInstance?.exports␊
+      const pending = exports?.napi_wasm_async_work_pending␊
+      const cancelPending = exports?.napi_wasm_cancel_pending_async_work␊
+      if (typeof pending !== 'function' || typeof cancelPending !== 'function') {␊
+        return␊
+      }␊
+    ␊
+      const readPending = () => {␊
+        try {␊
+          return pending()␊
+        } catch (error) {␊
+          // A trap is the only way this call fails: it reads a counter and cannot␊
+          // allocate or call back into JavaScript. A trapped instance can no longer␊
+          // run anything, so its outstanding work is unreachable by definition —␊
+          // there is nothing left to wait for, and refusing to dispose would only␊
+          // keep a dead instance and its stuck counter alive. Best-effort here is␊
+          // the honest answer, and it is what disposal did before this drain␊
+          // existed.␊
+          //␊
+          // Only a trap. Anything else means the export is not what this loader␊
+          // thinks it is, which is a defect worth surfacing rather than disposing␊
+          // over.␊
+          if (error instanceof globalThis.WebAssembly.RuntimeError) {␊
+            return 0␊
+          }␊
+          throw error␊
+        }␊
+      }␊
+    ␊
+      if (!readPending()) {␊
+        return␊
+      }␊
+      try {␊
+        cancelPending()␊
+      } catch {␊
+        // Cancellation is an optimization: it bounds the wait by the work already␊
+        // executing. Failing it only means waiting for the whole queue instead.␊
+      }␊
+      if (!readPending()) {␊
+        return␊
+      }␊
+    ␊
+      const drainPromise = __keepEventLoopAliveUntil(␊
+        (async () => {␊
+          while (readPending()) {␊
+            await new Promise((resolve) => {␊
+              __scheduleTimer(resolve, __WASI_ASYNC_WORK_POLL_INTERVAL_MS)␊
+            })␊
+          }␊
+        })(),␊
+      ).then(␊
+        () => {␊
+          __wasiAsyncWorkDrainPromise = undefined␊
+        },␊
+        (error) => {␊
+          // A wait that could not run is not a wait that finished. The only way␊
+          // here is a host whose timers and macrotask primitives all refuse, and␊
+          // the work is still outstanding — reporting success would destroy the␊
+          // environment over it, which is the stranding this exists to prevent.␊
+          // Reject instead: disposal stays retryable, and the context is not␊
+          // destroyed. Clearing the memo first is what makes the retry re-run this.␊
+          __wasiAsyncWorkDrainPromise = undefined␊
+          throw error␊
+        },␊
+      )␊
+      __wasiAsyncWorkDrainPromise = drainPromise␊
+      return drainPromise␊
+    }␊
+    ␊
+    /**␊
+     * \`@emnapi/wasi-threads\` counts a worker exit as expected only when its own␊
+     * thread manager performed the termination. A bare \`worker.terminate()\` reaches␊
+     * the manager's \`exit\` listener instead, which reports␊
+     * \`worker (tid = N) sent an error! ... stopped with exit code 1\` and rethrows␊
+     * inside the emit — aborting the \`once('exit')\` that backs the terminate␊
+     * promise, so disposal never settles and the process dies with an uncaught␊
+     * exception. Mark the termination through the manager first.␊
+     *␊
+     * The manager comes from \`__getWasiThreadManager\`, not from \`__napiModule\`:␊
+     * the initialization rollback runs on the one path where instantiation never␊
+     * returned, so \`__napiModule\` is still undefined there while the workers it␊
+     * spawned are already registered and loaded.␊
+     *␊
+     * Not \`terminateAllThreads()\`: that one recreates the pool it just shut down.␊
+     */␊
     function __terminateWasiWorkers() {␊
       const cleanupErrors = []␊
       const pending = []␊
+      const threadManager = __getWasiThreadManager()␊
     ␊
       for (const worker of __wasiWorkers) {␊
         let result␊
         try {␊
+          if (threadManager) {␊
+            threadManager.terminateWorker(worker)␊
+            // \`terminateWorker\` leaves behind a reporter that logs every message␊
+            // still queued on the port, which Node flushes on exit. Nothing is␊
+            // listening for those any more.␊
+            worker.onmessage = undefined␊
+          }␊
           result = worker.terminate()␊
         } catch (error) {␊
           cleanupErrors.push(error)␊
@@ -1172,7 +1712,9 @@ Generated by [AVA](https://avajs.dev).
           )␊
         }␊
       }␊
-      return pending.length > 0 ? Promise.all(pending).then(finish) : finish()␊
+      return pending.length > 0␊
+        ? __keepEventLoopAliveUntil(Promise.all(pending)).then(finish)␊
+        : finish()␊
     }␊
     ␊
     function __finishWasiDisposal() {␊
@@ -1191,7 +1733,7 @@ Generated by [AVA](https://avajs.dev).
       return __finishWasiDisposal()␊
     }␊
     ␊
-    function __startWasiDisposal() {␊
+    function __cleanUpWasmEnvForWasiDisposal() {␊
       // Run the pre-teardown barrier, then let the settlements it queued actually␊
       // reach JavaScript, and only then destroy the environment. Doing these two␊
       // back to back is what strands them.␊
@@ -1203,6 +1745,21 @@ Generated by [AVA](https://avajs.dev).
       return __continueWasiDisposal()␊
     }␊
     ␊
+    function __startWasiDisposal() {␊
+      // Outstanding \`napi_async_work\` goes first, while the environment is still␊
+      // completely live: the completion callbacks run addon code, and everything␊
+      // after this point takes that away from them — the barrier shuts the async␊
+      // runtime down, \`Context.destroy()\` stops JavaScript calls, and terminating␊
+      // the pool threads removes what would have reported the work finished.␊
+      const asyncWorkResult = __drainWasiAsyncWork()␊
+      if (__isThenable(asyncWorkResult)) {␊
+        return Promise.resolve(asyncWorkResult).then(␊
+          __cleanUpWasmEnvForWasiDisposal,␊
+        )␊
+      }␊
+      return __cleanUpWasmEnvForWasiDisposal()␊
+    }␊
+    ␊
     /**␊
      * Disposes this generated WASI binding.␊
      *␊
@@ -1344,29 +1901,60 @@ Generated by [AVA](https://avajs.dev).
      * bug with no upper bound, while the retained bookkeeping is bounded by the page.␊
      */␊
     function __rollbackWasiInitialization() {␊
-      const cleanupErrors = []␊
-      let drainResult␊
-      let settlementsUnreached = false␊
+      // The environment teardown this rollback performs, kept nested so it cannot␊
+      // be reached without the async-work drain below running first.␊
+      function __rollbackWasmEnvForWasiInitialization() {␊
+        const cleanupErrors = []␊
+        let drainResult␊
+        let settlementsUnreached = false␊
+        try {␊
+          __prepareWasmEnvCleanup()␊
+          drainResult = __drainWasmEnvCleanup()␊
+        } catch (cleanupError) {␊
+          cleanupErrors.push(cleanupError)␊
+          settlementsUnreached = true␊
+        }␊
+        if (__isThenable(drainResult)) {␊
+          return Promise.resolve(drainResult).then(␊
+            () => __destroyContextForWasiRollback(cleanupErrors),␊
+            (cleanupError) => {␊
+              cleanupErrors.push(cleanupError)␊
+              return __retainFailedWasiRollback(cleanupErrors)␊
+            },␊
+          )␊
+        }␊
+        if (settlementsUnreached) {␊
+          return __retainFailedWasiRollback(cleanupErrors)␊
+        }␊
+        return __destroyContextForWasiRollback(cleanupErrors)␊
+      }␊
+    ␊
+      // Same reason as \`__startWasiDisposal\`: a module-init hook can start async␊
+      // work before the load goes on to fail, and this rollback tears down exactly␊
+      // what those completions need. Settle them while everything is still live,␊
+      // before the barrier and the teardown above take that away.␊
+      //␊
+      // A drain that could not finish leaves async work possibly outstanding, and␊
+      // destroying the context over it would strand exactly what this rollback is␊
+      // there to settle. Stop short and retain instead — the same trade␊
+      // \`__rollbackWasmEnvForWasiInitialization\` makes for the settlement drain, so␊
+      // the context stays reclaimable by a retry or by this flavor's own␊
+      // last-resort teardown.␊
+      const __retainAfterAsyncWorkDrainFailure = (cleanupError) =>␊
+        __retainFailedWasiRollback([cleanupError])␊
+      let asyncWorkResult␊
       try {␊
-        __prepareWasmEnvCleanup()␊
-        drainResult = __drainWasmEnvCleanup()␊
+        asyncWorkResult = __drainWasiAsyncWork()␊
       } catch (cleanupError) {␊
-        cleanupErrors.push(cleanupError)␊
-        settlementsUnreached = true␊
+        return __retainAfterAsyncWorkDrainFailure(cleanupError)␊
       }␊
-      if (__isThenable(drainResult)) {␊
-        return Promise.resolve(drainResult).then(␊
-          () => __destroyContextForWasiRollback(cleanupErrors),␊
-          (cleanupError) => {␊
-            cleanupErrors.push(cleanupError)␊
-            return __retainFailedWasiRollback(cleanupErrors)␊
-          },␊
+      if (__isThenable(asyncWorkResult)) {␊
+        return Promise.resolve(asyncWorkResult).then(␊
+          __rollbackWasmEnvForWasiInitialization,␊
+          __retainAfterAsyncWorkDrainFailure,␊
         )␊
       }␊
-      if (settlementsUnreached) {␊
-        return __retainFailedWasiRollback(cleanupErrors)␊
-      }␊
-      return __destroyContextForWasiRollback(cleanupErrors)␊
+      return __rollbackWasmEnvForWasiInitialization()␊
     }␊
     ␊
     let __wasiModule␊
@@ -1388,7 +1976,11 @@ Generated by [AVA](https://avajs.dev).
         context: __emnapiContext,␊
         asyncWorkPoolSize: __asyncWorkPoolSize,␊
         reuseWorker: { size: __asyncWorkPoolSize + __workerPoolSize },␊
-        plugins: [__emnapiAsyncWorkPlugin, __emnapiTSFNPlugin],␊
+        plugins: [␊
+          __captureWasiThreadManager,␊
+          __emnapiAsyncWorkPlugin,␊
+          __emnapiTSFNPlugin,␊
+        ],␊
         wasi: __wasi,␊
         onCreateWorker() {␊
           const worker = new Worker(new URL('./wasi-worker-browser.mjs', import.meta.url), {␊
@@ -1546,6 +2138,35 @@ Generated by [AVA](https://avajs.dev).
     ␊
     const __wasiDisposeSymbol = Symbol.for('napi.rs.wasi.dispose')␊
     const __wasiWorkers = new Set()␊
+    // The thread manager has to be reachable *before* anything that can throw␊
+    // during load or registration. Initialization can fail after the pool has␊
+    // already spawned workers, and the rollback still has to mark their␊
+    // terminations as expected — but \`__napiModule\` is assigned only when␊
+    // instantiation RETURNS, so on exactly that path it is still undefined. A␊
+    // plugin factory runs while the emnapi module is being created, before the␊
+    // wasm is loaded and before any registration function runs, and its context␊
+    // carries the very same manager instance.␊
+    let __wasiThreadManager␊
+    ␊
+    function __captureWasiThreadManager(context) {␊
+      if (context && context.PThread) {␊
+        __wasiThreadManager = context.PThread␊
+      }␊
+      return {}␊
+    }␊
+    ␊
+    function __getWasiThreadManager() {␊
+      const manager =␊
+        __wasiThreadManager !== undefined␊
+          ? __wasiThreadManager␊
+          : __napiModule␊
+            ? __napiModule.PThread␊
+            : undefined␊
+      if (manager && typeof manager.terminateWorker === 'function') {␊
+        return manager␊
+      }␊
+      return undefined␊
+    }␊
     let __napiInstance␊
     let __emnapiContextDestroyed = false␊
     let __emnapiContextDestroyPromise␊
@@ -1555,6 +2176,7 @@ Generated by [AVA](https://avajs.dev).
     let __emnapiWasmEnvCleanupDrained = false␊
     let __emnapiWasmEnvCleanupDrainPromise␊
     let __wasiDisposed = false␊
+    let __wasiAsyncWorkDrainPromise␊
     let __wasiDisposePromise␊
     let __completeWasiDisposal = function () {}␊
     // Overridden by loader flavors that have a last-resort reclaim for a rollback␊
@@ -1712,6 +2334,24 @@ Generated by [AVA](https://avajs.dev).
       }␊
     })()␊
     ␊
+    // A real, *referenced* timer, for waits that must let the whole host make␊
+    // progress between looks — the async-work drain polls the addon rather than␊
+    // interleaving with the @emnapi/core dispatch, so a zero-delay macrotask there␊
+    // would spin the loop instead of yielding it. Falls back to the macrotask␊
+    // scheduler on a host without timers.␊
+    function __scheduleTimer(callback, delay) {␊
+      const setTimer = globalThis.setTimeout␊
+      if (typeof setTimer !== 'function') {␊
+        __scheduleMacrotask(callback)␊
+        return␊
+      }␊
+      try {␊
+        setTimer(callback, delay)␊
+      } catch {␊
+        __scheduleMacrotask(callback)␊
+      }␊
+    }␊
+    ␊
     // Turns to wait for while the addon still reports queued settlements. Reaching␊
     // zero is the only success. A counter still nonzero at this bound rejects the␊
     // disposal as retryable (\`ERR_NAPI_WASI_CLEANUP_PENDING\`) rather than␊
@@ -1868,13 +2508,209 @@ Generated by [AVA](https://avajs.dev).
       return destroyPromise␊
     }␊
     ␊
+    /**␊
+     * Holds the event loop open until \`work\` settles.␊
+     *␊
+     * Nothing else can: the pool workers are deliberately unreferenced so an idle␊
+     * binding cannot keep a process alive, and referencing them again for the␊
+     * termination does not hold either — emnapi unreferences a worker the moment it␊
+     * reports \`async-thread-ready\`, which for a worker that was still starting␊
+     * lands *after* the termination began. Without a handle of its own, an␊
+     * \`await dispose()\` with nothing else pending exits the process with its␊
+     * promise unsettled, and everything after the \`await\` is skipped.␊
+     *␊
+     * The timer is cleared as soon as the work settles, so this never outlives the␊
+     * disposal that asked for it.␊
+     */␊
+    function __keepEventLoopAliveUntil(work) {␊
+      const setTimer = globalThis.setInterval␊
+      const clearTimer = globalThis.clearInterval␊
+      if (typeof setTimer !== 'function' || typeof clearTimer !== 'function') {␊
+        return work␊
+      }␊
+      let timer␊
+      try {␊
+        timer = setTimer(function () {}, 50)␊
+      } catch {␊
+        return work␊
+      }␊
+      const release = function () {␊
+        try {␊
+          clearTimer(timer)␊
+        } catch {}␊
+      }␊
+      return work.then(␊
+        (value) => {␊
+          release()␊
+          return value␊
+        },␊
+        (error) => {␊
+          release()␊
+          throw error␊
+        },␊
+      )␊
+    }␊
+    ␊
+    // How often to re-read \`napi_wasm_async_work_pending\` while waiting. The wait␊
+    // ends when the addon reports zero, so this only decides how promptly disposal␊
+    // notices — not how long it waits.␊
+    const __WASI_ASYNC_WORK_POLL_INTERVAL_MS = 1␊
+    ␊
+    /**␊
+     * Settles this addon's outstanding \`napi_async_work\` before the teardown that␊
+     * would strand it.␊
+     *␊
+     * \`napi_prepare_wasm_env_cleanup\` does not cover async work, and nothing about␊
+     * it is observable from JavaScript: the threadless archive resolves␊
+     * \`napi_*_async_work\` through the \`@emnapi/core\` plugins, but the threaded one␊
+     * links the C \`async_work.c\` on the uv threadpool, so there the wasm neither␊
+     * imports nor exports those symbols and the only brackets a loader could watch␊
+     * (\`_emnapi_ctx_*_waiting_request_counter\`) are shared with threadsafe␊
+     * functions. The addon is the one place both flavors go through, so it answers␊
+     * for both, through the same kind of handshake the settlement drain uses:␊
+     *␊
+     *   - \`napi_wasm_cancel_pending_async_work()\` cancels what no thread has␊
+     *     started. Those completion callbacks run with \`napi_cancelled\`, which␊
+     *     napi-rs turns into a promise rejected with an \`AbortError\`.␊
+     *   - \`napi_wasm_async_work_pending()\` counts what is still owed a completion␊
+     *     callback. Work already executing refuses cancellation and stays counted␊
+     *     until it finishes normally — which it can, because this runs before the␊
+     *     barrier, before \`Context.destroy()\` and before anything is terminated.␊
+     *␊
+     * Both exports are optional: an addon built against a napi crate that predates␊
+     * them drains nothing and keeps the previous behavior, exactly as the␊
+     * \`napi_wasm_env_cleanup_pending\` handshake degrades.␊
+     *␊
+     * Returns nothing when there is nothing outstanding, which keeps disposal␊
+     * synchronous in the common case. The promise it returns otherwise never␊
+     * rejects.␊
+     *␊
+     * The wait has no deadline, and that is the point: giving up would destroy the␊
+     * environment with a completion callback still owed, which is the stranding␊
+     * this exists to prevent. A task whose \`execute\` never returns already keeps an␊
+     * *undisposed* process alive in exactly the same way, so disposal inherits that␊
+     * rather than inventing a bound it cannot honor.␊
+     *␊
+     * Safe to call from inside a completion callback, which is reachable: settling␊
+     * a task runs addon code that can re-enter JavaScript — a setter on the value␊
+     * being handed back, a threadsafe-function callback — and that JavaScript can␊
+     * call \`dispose()\`. Two things make it terminate rather than wait on itself:␊
+     *␊
+     *   - The addon keeps a work registered until its completion callback␊
+     *     *finishes*, so the count read here is at least one and this takes the␊
+     *     polling path instead of declaring the environment drained and tearing it␊
+     *     down from inside the frame that is still settling a promise.␊
+     *   - The poll is a timer, so it cannot run until the callback has returned to␊
+     *     the host — by which time that work has left the registry. The count the␊
+     *     next poll reads is the one taken after the callback finished.␊
+     *␊
+     * \`__disposeWasiBinding\` hands every caller the same in-flight promise, so the␊
+     * nested call joins this disposal rather than starting a second one.␊
+     */␊
+    function __drainWasiAsyncWork() {␊
+      if (__wasiAsyncWorkDrainPromise !== undefined) {␊
+        return __wasiAsyncWorkDrainPromise␊
+      }␊
+      const exports = __napiInstance?.exports␊
+      const pending = exports?.napi_wasm_async_work_pending␊
+      const cancelPending = exports?.napi_wasm_cancel_pending_async_work␊
+      if (typeof pending !== 'function' || typeof cancelPending !== 'function') {␊
+        return␊
+      }␊
+    ␊
+      const readPending = () => {␊
+        try {␊
+          return pending()␊
+        } catch (error) {␊
+          // A trap is the only way this call fails: it reads a counter and cannot␊
+          // allocate or call back into JavaScript. A trapped instance can no longer␊
+          // run anything, so its outstanding work is unreachable by definition —␊
+          // there is nothing left to wait for, and refusing to dispose would only␊
+          // keep a dead instance and its stuck counter alive. Best-effort here is␊
+          // the honest answer, and it is what disposal did before this drain␊
+          // existed.␊
+          //␊
+          // Only a trap. Anything else means the export is not what this loader␊
+          // thinks it is, which is a defect worth surfacing rather than disposing␊
+          // over.␊
+          if (error instanceof globalThis.WebAssembly.RuntimeError) {␊
+            return 0␊
+          }␊
+          throw error␊
+        }␊
+      }␊
+    ␊
+      if (!readPending()) {␊
+        return␊
+      }␊
+      try {␊
+        cancelPending()␊
+      } catch {␊
+        // Cancellation is an optimization: it bounds the wait by the work already␊
+        // executing. Failing it only means waiting for the whole queue instead.␊
+      }␊
+      if (!readPending()) {␊
+        return␊
+      }␊
+    ␊
+      const drainPromise = __keepEventLoopAliveUntil(␊
+        (async () => {␊
+          while (readPending()) {␊
+            await new Promise((resolve) => {␊
+              __scheduleTimer(resolve, __WASI_ASYNC_WORK_POLL_INTERVAL_MS)␊
+            })␊
+          }␊
+        })(),␊
+      ).then(␊
+        () => {␊
+          __wasiAsyncWorkDrainPromise = undefined␊
+        },␊
+        (error) => {␊
+          // A wait that could not run is not a wait that finished. The only way␊
+          // here is a host whose timers and macrotask primitives all refuse, and␊
+          // the work is still outstanding — reporting success would destroy the␊
+          // environment over it, which is the stranding this exists to prevent.␊
+          // Reject instead: disposal stays retryable, and the context is not␊
+          // destroyed. Clearing the memo first is what makes the retry re-run this.␊
+          __wasiAsyncWorkDrainPromise = undefined␊
+          throw error␊
+        },␊
+      )␊
+      __wasiAsyncWorkDrainPromise = drainPromise␊
+      return drainPromise␊
+    }␊
+    ␊
+    /**␊
+     * \`@emnapi/wasi-threads\` counts a worker exit as expected only when its own␊
+     * thread manager performed the termination. A bare \`worker.terminate()\` reaches␊
+     * the manager's \`exit\` listener instead, which reports␊
+     * \`worker (tid = N) sent an error! ... stopped with exit code 1\` and rethrows␊
+     * inside the emit — aborting the \`once('exit')\` that backs the terminate␊
+     * promise, so disposal never settles and the process dies with an uncaught␊
+     * exception. Mark the termination through the manager first.␊
+     *␊
+     * The manager comes from \`__getWasiThreadManager\`, not from \`__napiModule\`:␊
+     * the initialization rollback runs on the one path where instantiation never␊
+     * returned, so \`__napiModule\` is still undefined there while the workers it␊
+     * spawned are already registered and loaded.␊
+     *␊
+     * Not \`terminateAllThreads()\`: that one recreates the pool it just shut down.␊
+     */␊
     function __terminateWasiWorkers() {␊
       const cleanupErrors = []␊
       const pending = []␊
+      const threadManager = __getWasiThreadManager()␊
     ␊
       for (const worker of __wasiWorkers) {␊
         let result␊
         try {␊
+          if (threadManager) {␊
+            threadManager.terminateWorker(worker)␊
+            // \`terminateWorker\` leaves behind a reporter that logs every message␊
+            // still queued on the port, which Node flushes on exit. Nothing is␊
+            // listening for those any more.␊
+            worker.onmessage = undefined␊
+          }␊
           result = worker.terminate()␊
         } catch (error) {␊
           cleanupErrors.push(error)␊
@@ -1904,7 +2740,9 @@ Generated by [AVA](https://avajs.dev).
           )␊
         }␊
       }␊
-      return pending.length > 0 ? Promise.all(pending).then(finish) : finish()␊
+      return pending.length > 0␊
+        ? __keepEventLoopAliveUntil(Promise.all(pending)).then(finish)␊
+        : finish()␊
     }␊
     ␊
     function __finishWasiDisposal() {␊
@@ -1923,7 +2761,7 @@ Generated by [AVA](https://avajs.dev).
       return __finishWasiDisposal()␊
     }␊
     ␊
-    function __startWasiDisposal() {␊
+    function __cleanUpWasmEnvForWasiDisposal() {␊
       // Run the pre-teardown barrier, then let the settlements it queued actually␊
       // reach JavaScript, and only then destroy the environment. Doing these two␊
       // back to back is what strands them.␊
@@ -1935,6 +2773,21 @@ Generated by [AVA](https://avajs.dev).
       return __continueWasiDisposal()␊
     }␊
     ␊
+    function __startWasiDisposal() {␊
+      // Outstanding \`napi_async_work\` goes first, while the environment is still␊
+      // completely live: the completion callbacks run addon code, and everything␊
+      // after this point takes that away from them — the barrier shuts the async␊
+      // runtime down, \`Context.destroy()\` stops JavaScript calls, and terminating␊
+      // the pool threads removes what would have reported the work finished.␊
+      const asyncWorkResult = __drainWasiAsyncWork()␊
+      if (__isThenable(asyncWorkResult)) {␊
+        return Promise.resolve(asyncWorkResult).then(␊
+          __cleanUpWasmEnvForWasiDisposal,␊
+        )␊
+      }␊
+      return __cleanUpWasmEnvForWasiDisposal()␊
+    }␊
+    ␊
     /**␊
      * Disposes this generated WASI binding.␊
      *␊
@@ -2076,29 +2929,60 @@ Generated by [AVA](https://avajs.dev).
      * bug with no upper bound, while the retained bookkeeping is bounded by the page.␊
      */␊
     function __rollbackWasiInitialization() {␊
-      const cleanupErrors = []␊
-      let drainResult␊
-      let settlementsUnreached = false␊
+      // The environment teardown this rollback performs, kept nested so it cannot␊
+      // be reached without the async-work drain below running first.␊
+      function __rollbackWasmEnvForWasiInitialization() {␊
+        const cleanupErrors = []␊
+        let drainResult␊
+        let settlementsUnreached = false␊
+        try {␊
+          __prepareWasmEnvCleanup()␊
+          drainResult = __drainWasmEnvCleanup()␊
+        } catch (cleanupError) {␊
+          cleanupErrors.push(cleanupError)␊
+          settlementsUnreached = true␊
+        }␊
+        if (__isThenable(drainResult)) {␊
+          return Promise.resolve(drainResult).then(␊
+            () => __destroyContextForWasiRollback(cleanupErrors),␊
+            (cleanupError) => {␊
+              cleanupErrors.push(cleanupError)␊
+              return __retainFailedWasiRollback(cleanupErrors)␊
+            },␊
+          )␊
+        }␊
+        if (settlementsUnreached) {␊
+          return __retainFailedWasiRollback(cleanupErrors)␊
+        }␊
+        return __destroyContextForWasiRollback(cleanupErrors)␊
+      }␊
+    ␊
+      // Same reason as \`__startWasiDisposal\`: a module-init hook can start async␊
+      // work before the load goes on to fail, and this rollback tears down exactly␊
+      // what those completions need. Settle them while everything is still live,␊
+      // before the barrier and the teardown above take that away.␊
+      //␊
+      // A drain that could not finish leaves async work possibly outstanding, and␊
+      // destroying the context over it would strand exactly what this rollback is␊
+      // there to settle. Stop short and retain instead — the same trade␊
+      // \`__rollbackWasmEnvForWasiInitialization\` makes for the settlement drain, so␊
+      // the context stays reclaimable by a retry or by this flavor's own␊
+      // last-resort teardown.␊
+      const __retainAfterAsyncWorkDrainFailure = (cleanupError) =>␊
+        __retainFailedWasiRollback([cleanupError])␊
+      let asyncWorkResult␊
       try {␊
-        __prepareWasmEnvCleanup()␊
-        drainResult = __drainWasmEnvCleanup()␊
+        asyncWorkResult = __drainWasiAsyncWork()␊
       } catch (cleanupError) {␊
-        cleanupErrors.push(cleanupError)␊
-        settlementsUnreached = true␊
+        return __retainAfterAsyncWorkDrainFailure(cleanupError)␊
       }␊
-      if (__isThenable(drainResult)) {␊
-        return Promise.resolve(drainResult).then(␊
-          () => __destroyContextForWasiRollback(cleanupErrors),␊
-          (cleanupError) => {␊
-            cleanupErrors.push(cleanupError)␊
-            return __retainFailedWasiRollback(cleanupErrors)␊
-          },␊
+      if (__isThenable(asyncWorkResult)) {␊
+        return Promise.resolve(asyncWorkResult).then(␊
+          __rollbackWasmEnvForWasiInitialization,␊
+          __retainAfterAsyncWorkDrainFailure,␊
         )␊
       }␊
-      if (settlementsUnreached) {␊
-        return __retainFailedWasiRollback(cleanupErrors)␊
-      }␊
-      return __destroyContextForWasiRollback(cleanupErrors)␊
+      return __rollbackWasmEnvForWasiInitialization()␊
     }␊
     ␊
     let __wasiModule␊
@@ -2120,7 +3004,11 @@ Generated by [AVA](https://avajs.dev).
         context: __emnapiContext,␊
         asyncWorkPoolSize: __asyncWorkPoolSize,␊
         reuseWorker: { size: __asyncWorkPoolSize + __workerPoolSize },␊
-        plugins: [__emnapiAsyncWorkPlugin, __emnapiTSFNPlugin],␊
+        plugins: [␊
+          __captureWasiThreadManager,␊
+          __emnapiAsyncWorkPlugin,␊
+          __emnapiTSFNPlugin,␊
+        ],␊
         wasi: __wasi,␊
         onCreateWorker() {␊
           const worker = new Worker(new URL('./wasi-worker-browser.mjs', import.meta.url), {␊
@@ -2266,6 +3154,35 @@ Generated by [AVA](https://avajs.dev).
     ␊
     const __wasiDisposeSymbol = Symbol.for('napi.rs.wasi.dispose')␊
     const __wasiWorkers = new Set()␊
+    // The thread manager has to be reachable *before* anything that can throw␊
+    // during load or registration. Initialization can fail after the pool has␊
+    // already spawned workers, and the rollback still has to mark their␊
+    // terminations as expected — but \`__napiModule\` is assigned only when␊
+    // instantiation RETURNS, so on exactly that path it is still undefined. A␊
+    // plugin factory runs while the emnapi module is being created, before the␊
+    // wasm is loaded and before any registration function runs, and its context␊
+    // carries the very same manager instance.␊
+    let __wasiThreadManager␊
+    ␊
+    function __captureWasiThreadManager(context) {␊
+      if (context && context.PThread) {␊
+        __wasiThreadManager = context.PThread␊
+      }␊
+      return {}␊
+    }␊
+    ␊
+    function __getWasiThreadManager() {␊
+      const manager =␊
+        __wasiThreadManager !== undefined␊
+          ? __wasiThreadManager␊
+          : __napiModule␊
+            ? __napiModule.PThread␊
+            : undefined␊
+      if (manager && typeof manager.terminateWorker === 'function') {␊
+        return manager␊
+      }␊
+      return undefined␊
+    }␊
     let __napiInstance␊
     let __emnapiContextDestroyed = false␊
     let __emnapiContextDestroyPromise␊
@@ -2275,6 +3192,7 @@ Generated by [AVA](https://avajs.dev).
     let __emnapiWasmEnvCleanupDrained = false␊
     let __emnapiWasmEnvCleanupDrainPromise␊
     let __wasiDisposed = false␊
+    let __wasiAsyncWorkDrainPromise␊
     let __wasiDisposePromise␊
     let __completeWasiDisposal = function () {}␊
     // Overridden by loader flavors that have a last-resort reclaim for a rollback␊
@@ -2462,6 +3380,24 @@ Generated by [AVA](https://avajs.dev).
       }␊
     })()␊
     ␊
+    // A real, *referenced* timer, for waits that must let the whole host make␊
+    // progress between looks — the async-work drain polls the addon rather than␊
+    // interleaving with the @emnapi/core dispatch, so a zero-delay macrotask there␊
+    // would spin the loop instead of yielding it. Falls back to the macrotask␊
+    // scheduler on a host without timers.␊
+    function __scheduleTimer(callback, delay) {␊
+      const setTimer = globalThis.setTimeout␊
+      if (typeof setTimer !== 'function') {␊
+        __scheduleMacrotask(callback)␊
+        return␊
+      }␊
+      try {␊
+        setTimer(callback, delay)␊
+      } catch {␊
+        __scheduleMacrotask(callback)␊
+      }␊
+    }␊
+    ␊
     // Turns to wait for while the addon still reports queued settlements. Reaching␊
     // zero is the only success. A counter still nonzero at this bound rejects the␊
     // disposal as retryable (\`ERR_NAPI_WASI_CLEANUP_PENDING\`) rather than␊
@@ -2619,13 +3555,209 @@ Generated by [AVA](https://avajs.dev).
       return destroyPromise␊
     }␊
     ␊
+    /**␊
+     * Holds the event loop open until \`work\` settles.␊
+     *␊
+     * Nothing else can: the pool workers are deliberately unreferenced so an idle␊
+     * binding cannot keep a process alive, and referencing them again for the␊
+     * termination does not hold either — emnapi unreferences a worker the moment it␊
+     * reports \`async-thread-ready\`, which for a worker that was still starting␊
+     * lands *after* the termination began. Without a handle of its own, an␊
+     * \`await dispose()\` with nothing else pending exits the process with its␊
+     * promise unsettled, and everything after the \`await\` is skipped.␊
+     *␊
+     * The timer is cleared as soon as the work settles, so this never outlives the␊
+     * disposal that asked for it.␊
+     */␊
+    function __keepEventLoopAliveUntil(work) {␊
+      const setTimer = globalThis.setInterval␊
+      const clearTimer = globalThis.clearInterval␊
+      if (typeof setTimer !== 'function' || typeof clearTimer !== 'function') {␊
+        return work␊
+      }␊
+      let timer␊
+      try {␊
+        timer = setTimer(function () {}, 50)␊
+      } catch {␊
+        return work␊
+      }␊
+      const release = function () {␊
+        try {␊
+          clearTimer(timer)␊
+        } catch {}␊
+      }␊
+      return work.then(␊
+        (value) => {␊
+          release()␊
+          return value␊
+        },␊
+        (error) => {␊
+          release()␊
+          throw error␊
+        },␊
+      )␊
+    }␊
+    ␊
+    // How often to re-read \`napi_wasm_async_work_pending\` while waiting. The wait␊
+    // ends when the addon reports zero, so this only decides how promptly disposal␊
+    // notices — not how long it waits.␊
+    const __WASI_ASYNC_WORK_POLL_INTERVAL_MS = 1␊
+    ␊
+    /**␊
+     * Settles this addon's outstanding \`napi_async_work\` before the teardown that␊
+     * would strand it.␊
+     *␊
+     * \`napi_prepare_wasm_env_cleanup\` does not cover async work, and nothing about␊
+     * it is observable from JavaScript: the threadless archive resolves␊
+     * \`napi_*_async_work\` through the \`@emnapi/core\` plugins, but the threaded one␊
+     * links the C \`async_work.c\` on the uv threadpool, so there the wasm neither␊
+     * imports nor exports those symbols and the only brackets a loader could watch␊
+     * (\`_emnapi_ctx_*_waiting_request_counter\`) are shared with threadsafe␊
+     * functions. The addon is the one place both flavors go through, so it answers␊
+     * for both, through the same kind of handshake the settlement drain uses:␊
+     *␊
+     *   - \`napi_wasm_cancel_pending_async_work()\` cancels what no thread has␊
+     *     started. Those completion callbacks run with \`napi_cancelled\`, which␊
+     *     napi-rs turns into a promise rejected with an \`AbortError\`.␊
+     *   - \`napi_wasm_async_work_pending()\` counts what is still owed a completion␊
+     *     callback. Work already executing refuses cancellation and stays counted␊
+     *     until it finishes normally — which it can, because this runs before the␊
+     *     barrier, before \`Context.destroy()\` and before anything is terminated.␊
+     *␊
+     * Both exports are optional: an addon built against a napi crate that predates␊
+     * them drains nothing and keeps the previous behavior, exactly as the␊
+     * \`napi_wasm_env_cleanup_pending\` handshake degrades.␊
+     *␊
+     * Returns nothing when there is nothing outstanding, which keeps disposal␊
+     * synchronous in the common case. The promise it returns otherwise never␊
+     * rejects.␊
+     *␊
+     * The wait has no deadline, and that is the point: giving up would destroy the␊
+     * environment with a completion callback still owed, which is the stranding␊
+     * this exists to prevent. A task whose \`execute\` never returns already keeps an␊
+     * *undisposed* process alive in exactly the same way, so disposal inherits that␊
+     * rather than inventing a bound it cannot honor.␊
+     *␊
+     * Safe to call from inside a completion callback, which is reachable: settling␊
+     * a task runs addon code that can re-enter JavaScript — a setter on the value␊
+     * being handed back, a threadsafe-function callback — and that JavaScript can␊
+     * call \`dispose()\`. Two things make it terminate rather than wait on itself:␊
+     *␊
+     *   - The addon keeps a work registered until its completion callback␊
+     *     *finishes*, so the count read here is at least one and this takes the␊
+     *     polling path instead of declaring the environment drained and tearing it␊
+     *     down from inside the frame that is still settling a promise.␊
+     *   - The poll is a timer, so it cannot run until the callback has returned to␊
+     *     the host — by which time that work has left the registry. The count the␊
+     *     next poll reads is the one taken after the callback finished.␊
+     *␊
+     * \`__disposeWasiBinding\` hands every caller the same in-flight promise, so the␊
+     * nested call joins this disposal rather than starting a second one.␊
+     */␊
+    function __drainWasiAsyncWork() {␊
+      if (__wasiAsyncWorkDrainPromise !== undefined) {␊
+        return __wasiAsyncWorkDrainPromise␊
+      }␊
+      const exports = __napiInstance?.exports␊
+      const pending = exports?.napi_wasm_async_work_pending␊
+      const cancelPending = exports?.napi_wasm_cancel_pending_async_work␊
+      if (typeof pending !== 'function' || typeof cancelPending !== 'function') {␊
+        return␊
+      }␊
+    ␊
+      const readPending = () => {␊
+        try {␊
+          return pending()␊
+        } catch (error) {␊
+          // A trap is the only way this call fails: it reads a counter and cannot␊
+          // allocate or call back into JavaScript. A trapped instance can no longer␊
+          // run anything, so its outstanding work is unreachable by definition —␊
+          // there is nothing left to wait for, and refusing to dispose would only␊
+          // keep a dead instance and its stuck counter alive. Best-effort here is␊
+          // the honest answer, and it is what disposal did before this drain␊
+          // existed.␊
+          //␊
+          // Only a trap. Anything else means the export is not what this loader␊
+          // thinks it is, which is a defect worth surfacing rather than disposing␊
+          // over.␊
+          if (error instanceof globalThis.WebAssembly.RuntimeError) {␊
+            return 0␊
+          }␊
+          throw error␊
+        }␊
+      }␊
+    ␊
+      if (!readPending()) {␊
+        return␊
+      }␊
+      try {␊
+        cancelPending()␊
+      } catch {␊
+        // Cancellation is an optimization: it bounds the wait by the work already␊
+        // executing. Failing it only means waiting for the whole queue instead.␊
+      }␊
+      if (!readPending()) {␊
+        return␊
+      }␊
+    ␊
+      const drainPromise = __keepEventLoopAliveUntil(␊
+        (async () => {␊
+          while (readPending()) {␊
+            await new Promise((resolve) => {␊
+              __scheduleTimer(resolve, __WASI_ASYNC_WORK_POLL_INTERVAL_MS)␊
+            })␊
+          }␊
+        })(),␊
+      ).then(␊
+        () => {␊
+          __wasiAsyncWorkDrainPromise = undefined␊
+        },␊
+        (error) => {␊
+          // A wait that could not run is not a wait that finished. The only way␊
+          // here is a host whose timers and macrotask primitives all refuse, and␊
+          // the work is still outstanding — reporting success would destroy the␊
+          // environment over it, which is the stranding this exists to prevent.␊
+          // Reject instead: disposal stays retryable, and the context is not␊
+          // destroyed. Clearing the memo first is what makes the retry re-run this.␊
+          __wasiAsyncWorkDrainPromise = undefined␊
+          throw error␊
+        },␊
+      )␊
+      __wasiAsyncWorkDrainPromise = drainPromise␊
+      return drainPromise␊
+    }␊
+    ␊
+    /**␊
+     * \`@emnapi/wasi-threads\` counts a worker exit as expected only when its own␊
+     * thread manager performed the termination. A bare \`worker.terminate()\` reaches␊
+     * the manager's \`exit\` listener instead, which reports␊
+     * \`worker (tid = N) sent an error! ... stopped with exit code 1\` and rethrows␊
+     * inside the emit — aborting the \`once('exit')\` that backs the terminate␊
+     * promise, so disposal never settles and the process dies with an uncaught␊
+     * exception. Mark the termination through the manager first.␊
+     *␊
+     * The manager comes from \`__getWasiThreadManager\`, not from \`__napiModule\`:␊
+     * the initialization rollback runs on the one path where instantiation never␊
+     * returned, so \`__napiModule\` is still undefined there while the workers it␊
+     * spawned are already registered and loaded.␊
+     *␊
+     * Not \`terminateAllThreads()\`: that one recreates the pool it just shut down.␊
+     */␊
     function __terminateWasiWorkers() {␊
       const cleanupErrors = []␊
       const pending = []␊
+      const threadManager = __getWasiThreadManager()␊
     ␊
       for (const worker of __wasiWorkers) {␊
         let result␊
         try {␊
+          if (threadManager) {␊
+            threadManager.terminateWorker(worker)␊
+            // \`terminateWorker\` leaves behind a reporter that logs every message␊
+            // still queued on the port, which Node flushes on exit. Nothing is␊
+            // listening for those any more.␊
+            worker.onmessage = undefined␊
+          }␊
           result = worker.terminate()␊
         } catch (error) {␊
           cleanupErrors.push(error)␊
@@ -2655,7 +3787,9 @@ Generated by [AVA](https://avajs.dev).
           )␊
         }␊
       }␊
-      return pending.length > 0 ? Promise.all(pending).then(finish) : finish()␊
+      return pending.length > 0␊
+        ? __keepEventLoopAliveUntil(Promise.all(pending)).then(finish)␊
+        : finish()␊
     }␊
     ␊
     function __finishWasiDisposal() {␊
@@ -2674,7 +3808,7 @@ Generated by [AVA](https://avajs.dev).
       return __finishWasiDisposal()␊
     }␊
     ␊
-    function __startWasiDisposal() {␊
+    function __cleanUpWasmEnvForWasiDisposal() {␊
       // Run the pre-teardown barrier, then let the settlements it queued actually␊
       // reach JavaScript, and only then destroy the environment. Doing these two␊
       // back to back is what strands them.␊
@@ -2686,6 +3820,21 @@ Generated by [AVA](https://avajs.dev).
       return __continueWasiDisposal()␊
     }␊
     ␊
+    function __startWasiDisposal() {␊
+      // Outstanding \`napi_async_work\` goes first, while the environment is still␊
+      // completely live: the completion callbacks run addon code, and everything␊
+      // after this point takes that away from them — the barrier shuts the async␊
+      // runtime down, \`Context.destroy()\` stops JavaScript calls, and terminating␊
+      // the pool threads removes what would have reported the work finished.␊
+      const asyncWorkResult = __drainWasiAsyncWork()␊
+      if (__isThenable(asyncWorkResult)) {␊
+        return Promise.resolve(asyncWorkResult).then(␊
+          __cleanUpWasmEnvForWasiDisposal,␊
+        )␊
+      }␊
+      return __cleanUpWasmEnvForWasiDisposal()␊
+    }␊
+    ␊
     /**␊
      * Disposes this generated WASI binding.␊
      *␊
@@ -2827,29 +3976,60 @@ Generated by [AVA](https://avajs.dev).
      * bug with no upper bound, while the retained bookkeeping is bounded by the page.␊
      */␊
     function __rollbackWasiInitialization() {␊
-      const cleanupErrors = []␊
-      let drainResult␊
-      let settlementsUnreached = false␊
+      // The environment teardown this rollback performs, kept nested so it cannot␊
+      // be reached without the async-work drain below running first.␊
+      function __rollbackWasmEnvForWasiInitialization() {␊
+        const cleanupErrors = []␊
+        let drainResult␊
+        let settlementsUnreached = false␊
+        try {␊
+          __prepareWasmEnvCleanup()␊
+          drainResult = __drainWasmEnvCleanup()␊
+        } catch (cleanupError) {␊
+          cleanupErrors.push(cleanupError)␊
+          settlementsUnreached = true␊
+        }␊
+        if (__isThenable(drainResult)) {␊
+          return Promise.resolve(drainResult).then(␊
+            () => __destroyContextForWasiRollback(cleanupErrors),␊
+            (cleanupError) => {␊
+              cleanupErrors.push(cleanupError)␊
+              return __retainFailedWasiRollback(cleanupErrors)␊
+            },␊
+          )␊
+        }␊
+        if (settlementsUnreached) {␊
+          return __retainFailedWasiRollback(cleanupErrors)␊
+        }␊
+        return __destroyContextForWasiRollback(cleanupErrors)␊
+      }␊
+    ␊
+      // Same reason as \`__startWasiDisposal\`: a module-init hook can start async␊
+      // work before the load goes on to fail, and this rollback tears down exactly␊
+      // what those completions need. Settle them while everything is still live,␊
+      // before the barrier and the teardown above take that away.␊
+      //␊
+      // A drain that could not finish leaves async work possibly outstanding, and␊
+      // destroying the context over it would strand exactly what this rollback is␊
+      // there to settle. Stop short and retain instead — the same trade␊
+      // \`__rollbackWasmEnvForWasiInitialization\` makes for the settlement drain, so␊
+      // the context stays reclaimable by a retry or by this flavor's own␊
+      // last-resort teardown.␊
+      const __retainAfterAsyncWorkDrainFailure = (cleanupError) =>␊
+        __retainFailedWasiRollback([cleanupError])␊
+      let asyncWorkResult␊
       try {␊
-        __prepareWasmEnvCleanup()␊
-        drainResult = __drainWasmEnvCleanup()␊
+        asyncWorkResult = __drainWasiAsyncWork()␊
       } catch (cleanupError) {␊
-        cleanupErrors.push(cleanupError)␊
-        settlementsUnreached = true␊
+        return __retainAfterAsyncWorkDrainFailure(cleanupError)␊
       }␊
-      if (__isThenable(drainResult)) {␊
-        return Promise.resolve(drainResult).then(␊
-          () => __destroyContextForWasiRollback(cleanupErrors),␊
-          (cleanupError) => {␊
-            cleanupErrors.push(cleanupError)␊
-            return __retainFailedWasiRollback(cleanupErrors)␊
-          },␊
+      if (__isThenable(asyncWorkResult)) {␊
+        return Promise.resolve(asyncWorkResult).then(␊
+          __rollbackWasmEnvForWasiInitialization,␊
+          __retainAfterAsyncWorkDrainFailure,␊
         )␊
       }␊
-      if (settlementsUnreached) {␊
-        return __retainFailedWasiRollback(cleanupErrors)␊
-      }␊
-      return __destroyContextForWasiRollback(cleanupErrors)␊
+      return __rollbackWasmEnvForWasiInitialization()␊
     }␊
     ␊
     let __wasiModule␊
@@ -2870,7 +4050,11 @@ Generated by [AVA](https://avajs.dev).
       } = __emnapiInstantiateNapiModuleSync(__wasmFile, {␊
         context: __emnapiContext,␊
         asyncWorkPoolSize: 0,␊
-        plugins: [__emnapiAsyncWorkPlugin, __emnapiTSFNPlugin],␊
+        plugins: [␊
+          __captureWasiThreadManager,␊
+          __emnapiAsyncWorkPlugin,␊
+          __emnapiTSFNPlugin,␊
+        ],␊
         wasi: __wasi,␊
         overwriteImports(importObject) {␊
           importObject.env = {␊
@@ -3383,6 +4567,101 @@ Generated by [AVA](https://avajs.dev).
       })()␊
     }␊
     ␊
+    // A real, *referenced* timer for the async-work wait below, which polls the␊
+    // addon rather than interleaving with the @emnapi/core dispatch: a zero-delay␊
+    // macrotask there would spin the loop instead of yielding it. Falls back to the␊
+    // macrotask scheduler on a host without timers.␊
+    function __scheduleTimer(__callback, __delay) {␊
+      const __setTimer = globalThis.setTimeout␊
+      if (typeof __setTimer !== 'function') {␊
+        __scheduleMacrotask(__callback)␊
+        return␊
+      }␊
+      try {␊
+        __setTimer(__callback, __delay)␊
+      } catch {␊
+        __scheduleMacrotask(__callback)␊
+      }␊
+    }␊
+    ␊
+    // How often to re-read \`napi_wasm_async_work_pending\` while waiting. The wait␊
+    // ends when the addon reports zero, so this only decides how promptly disposal␊
+    // notices — not how long it waits.␊
+    const __WASI_ASYNC_WORK_POLL_INTERVAL_MS = 1␊
+    ␊
+    /**␊
+     * Settles this instance's outstanding \`napi_async_work\` before the teardown␊
+     * that would strand it.␊
+     *␊
+     * The same hole the eager loaders had, and the same fix: the environment␊
+     * cleanup barrier covers promise settlements queued on the threadsafe-function␊
+     * queue and says nothing about \`napi_async_work\`, so destroying the context␊
+     * with a work still outstanding leaves its completion callback with nowhere to␊
+     * run and its promise unsettled forever.␊
+     *␊
+     * This flavor is threadless, so \`compute\` runs on the JavaScript thread inside␊
+     * the macrotask that dequeued it: while this is running, any outstanding work␊
+     * is queued rather than executing, and \`napi_wasm_cancel_pending_async_work\`␊
+     * can take all of it. The poll is still what decides when the drain is done —␊
+     * cancellation delivers those completions from a later macrotask, not␊
+     * synchronously.␊
+     *␊
+     * Per instance, from that instance's own exports: two instances of this loader␊
+     * have separate registries and must not wait on each other.␊
+     *␊
+     * Both exports are optional, so an addon built against a napi crate that␊
+     * predates them keeps the previous behavior.␊
+     *␊
+     * Returns nothing when there is nothing outstanding, which keeps disposal␊
+     * synchronous in the common case. No deadline: giving up would destroy the␊
+     * environment with a completion callback still owed.␊
+     */␊
+    function __drainInstanceAsyncWork(__instance) {␊
+      const __exports = __instance?.exports␊
+      const __pending = __exports?.napi_wasm_async_work_pending␊
+      const __cancelPending = __exports?.napi_wasm_cancel_pending_async_work␊
+      if (typeof __pending !== 'function' || typeof __cancelPending !== 'function') {␊
+        return␊
+      }␊
+    ␊
+      const __readPending = () => {␊
+        try {␊
+          return __pending()␊
+        } catch (__error) {␊
+          // A trap is the only way this call fails: it reads a counter and cannot␊
+          // allocate or call back into JavaScript. A trapped instance can no longer␊
+          // run anything, so its outstanding work is unreachable by definition and␊
+          // best-effort is the honest answer. Anything else means the export is not␊
+          // what this loader thinks it is — a defect worth surfacing.␊
+          if (__error instanceof globalThis.WebAssembly.RuntimeError) {␊
+            return 0␊
+          }␊
+          throw __error␊
+        }␊
+      }␊
+    ␊
+      if (!__readPending()) {␊
+        return␊
+      }␊
+      try {␊
+        __cancelPending()␊
+      } catch {␊
+        // Cancellation only bounds the wait. Failing it means waiting for the queue␊
+        // to run instead, which the poll below already does.␊
+      }␊
+      if (!__readPending()) {␊
+        return␊
+      }␊
+    ␊
+      return (async () => {␊
+        while (__readPending()) {␊
+          await new Promise((__resolve) => {␊
+            __scheduleTimer(__resolve, __WASI_ASYNC_WORK_POLL_INTERVAL_MS)␊
+          })␊
+        }␊
+      })()␊
+    }␊
+    ␊
     function __createLifecycleReentryError(__operation) {␊
       const __error = new Error(␊
         __operation +␊
@@ -3877,7 +5156,15 @@ Generated by [AVA](https://avajs.dev).
         if (__lifecycleState !== 'failed') {␊
           __lifecycleState = 'disposal'␊
         }␊
-        // Settle what the barrier cancelled before the environment stops␊
+        // Outstanding async work first, while the environment is still completely␊
+        // live: its completion callbacks run addon code, and the barrier and␊
+        // \`Context.destroy()\` below each take that away. Undefined unless work is␊
+        // outstanding.␊
+        const __asyncWorkDrained = __drainInstanceAsyncWork(__napiInstance)␊
+        if (__asyncWorkDrained) {␊
+          await __asyncWorkDrained␊
+        }␊
+        // Then settle what the barrier cancelled, before the environment stops␊
         // accepting JavaScript calls. Undefined unless something is queued, so␊
         // an idle disposal is not delayed by a single turn.␊
         const __drained = __prepareForDisposal()␊
@@ -4032,6 +5319,14 @@ Generated by [AVA](https://avajs.dev).
         // so a failure before beforeInit costs no extra turn.␊
         let __settlementsUnreached = false␊
         try {␊
+          // Registration can start async work too, and this path destroys the same␊
+          // environment its completions need. A drain that cannot finish leaves the␊
+          // work outstanding, so it counts as settlements unreached and stops the␊
+          // rollback short of destroying, exactly like a failed barrier drain.␊
+          const __asyncWorkDrained = __drainInstanceAsyncWork(__napiInstance)␊
+          if (__asyncWorkDrained) {␊
+            await __asyncWorkDrained␊
+          }␊
           const __drained = __prepareForDisposal()␊
           if (__drained) {␊
             await __drained␊
@@ -4770,6 +6065,101 @@ Generated by [AVA](https://avajs.dev).
       })()␊
     }␊
     ␊
+    // A real, *referenced* timer for the async-work wait below, which polls the␊
+    // addon rather than interleaving with the @emnapi/core dispatch: a zero-delay␊
+    // macrotask there would spin the loop instead of yielding it. Falls back to the␊
+    // macrotask scheduler on a host without timers.␊
+    function __scheduleTimer(__callback, __delay) {␊
+      const __setTimer = globalThis.setTimeout␊
+      if (typeof __setTimer !== 'function') {␊
+        __scheduleMacrotask(__callback)␊
+        return␊
+      }␊
+      try {␊
+        __setTimer(__callback, __delay)␊
+      } catch {␊
+        __scheduleMacrotask(__callback)␊
+      }␊
+    }␊
+    ␊
+    // How often to re-read \`napi_wasm_async_work_pending\` while waiting. The wait␊
+    // ends when the addon reports zero, so this only decides how promptly disposal␊
+    // notices — not how long it waits.␊
+    const __WASI_ASYNC_WORK_POLL_INTERVAL_MS = 1␊
+    ␊
+    /**␊
+     * Settles this instance's outstanding \`napi_async_work\` before the teardown␊
+     * that would strand it.␊
+     *␊
+     * The same hole the eager loaders had, and the same fix: the environment␊
+     * cleanup barrier covers promise settlements queued on the threadsafe-function␊
+     * queue and says nothing about \`napi_async_work\`, so destroying the context␊
+     * with a work still outstanding leaves its completion callback with nowhere to␊
+     * run and its promise unsettled forever.␊
+     *␊
+     * This flavor is threadless, so \`compute\` runs on the JavaScript thread inside␊
+     * the macrotask that dequeued it: while this is running, any outstanding work␊
+     * is queued rather than executing, and \`napi_wasm_cancel_pending_async_work\`␊
+     * can take all of it. The poll is still what decides when the drain is done —␊
+     * cancellation delivers those completions from a later macrotask, not␊
+     * synchronously.␊
+     *␊
+     * Per instance, from that instance's own exports: two instances of this loader␊
+     * have separate registries and must not wait on each other.␊
+     *␊
+     * Both exports are optional, so an addon built against a napi crate that␊
+     * predates them keeps the previous behavior.␊
+     *␊
+     * Returns nothing when there is nothing outstanding, which keeps disposal␊
+     * synchronous in the common case. No deadline: giving up would destroy the␊
+     * environment with a completion callback still owed.␊
+     */␊
+    function __drainInstanceAsyncWork(__instance) {␊
+      const __exports = __instance?.exports␊
+      const __pending = __exports?.napi_wasm_async_work_pending␊
+      const __cancelPending = __exports?.napi_wasm_cancel_pending_async_work␊
+      if (typeof __pending !== 'function' || typeof __cancelPending !== 'function') {␊
+        return␊
+      }␊
+    ␊
+      const __readPending = () => {␊
+        try {␊
+          return __pending()␊
+        } catch (__error) {␊
+          // A trap is the only way this call fails: it reads a counter and cannot␊
+          // allocate or call back into JavaScript. A trapped instance can no longer␊
+          // run anything, so its outstanding work is unreachable by definition and␊
+          // best-effort is the honest answer. Anything else means the export is not␊
+          // what this loader thinks it is — a defect worth surfacing.␊
+          if (__error instanceof globalThis.WebAssembly.RuntimeError) {␊
+            return 0␊
+          }␊
+          throw __error␊
+        }␊
+      }␊
+    ␊
+      if (!__readPending()) {␊
+        return␊
+      }␊
+      try {␊
+        __cancelPending()␊
+      } catch {␊
+        // Cancellation only bounds the wait. Failing it means waiting for the queue␊
+        // to run instead, which the poll below already does.␊
+      }␊
+      if (!__readPending()) {␊
+        return␊
+      }␊
+    ␊
+      return (async () => {␊
+        while (__readPending()) {␊
+          await new Promise((__resolve) => {␊
+            __scheduleTimer(__resolve, __WASI_ASYNC_WORK_POLL_INTERVAL_MS)␊
+          })␊
+        }␊
+      })()␊
+    }␊
+    ␊
     function __createLifecycleReentryError(__operation) {␊
       const __error = new Error(␊
         __operation +␊
@@ -5285,7 +6675,15 @@ Generated by [AVA](https://avajs.dev).
         if (__lifecycleState !== 'failed') {␊
           __lifecycleState = 'disposal'␊
         }␊
-        // Settle what the barrier cancelled before the environment stops␊
+        // Outstanding async work first, while the environment is still completely␊
+        // live: its completion callbacks run addon code, and the barrier and␊
+        // \`Context.destroy()\` below each take that away. Undefined unless work is␊
+        // outstanding.␊
+        const __asyncWorkDrained = __drainInstanceAsyncWork(__napiInstance)␊
+        if (__asyncWorkDrained) {␊
+          await __asyncWorkDrained␊
+        }␊
+        // Then settle what the barrier cancelled, before the environment stops␊
         // accepting JavaScript calls. Undefined unless something is queued, so␊
         // an idle disposal is not delayed by a single turn.␊
         const __drained = __prepareForDisposal()␊
@@ -5469,6 +6867,14 @@ Generated by [AVA](https://avajs.dev).
         // so a failure before beforeInit costs no extra turn.␊
         let __settlementsUnreached = false␊
         try {␊
+          // Registration can start async work too, and this path destroys the same␊
+          // environment its completions need. A drain that cannot finish leaves the␊
+          // work outstanding, so it counts as settlements unreached and stops the␊
+          // rollback short of destroying, exactly like a failed barrier drain.␊
+          const __asyncWorkDrained = __drainInstanceAsyncWork(__napiInstance)␊
+          if (__asyncWorkDrained) {␊
+            await __asyncWorkDrained␊
+          }␊
           const __drained = __prepareForDisposal()␊
           if (__drained) {␊
             await __drained␊