@napi-rs/cli 3.8.2 → 3.8.4

package/src/api/__tests__/pre-publish.spec.ts

@@ -1,6 +1,9 @@
 import test from 'ava'
 
-import { resolveRootOptionalDependencies } from '../pre-publish.js'
+import {
+  parseNpmPackFiles,
+  resolveRootOptionalDependencies,
+} from '../pre-publish.js'
 import { parseTriple } from '../../utils/index.js'
 
 const PACKAGE_NAME = '@scope/pkg'
@@ -104,3 +107,35 @@ test('preserves unmanaged optionalDependencies', (t) => {
     },
   )
 })
+
+const NPM_PACK_FILES = [
+  { path: './package.json' },
+  { path: 'dist\\index.js' },
+  { path: 42 },
+]
+
+test('parses npm 11 pack JSON output', (t) => {
+  t.deepEqual(
+    [...parseNpmPackFiles(JSON.stringify([{ files: NPM_PACK_FILES }]))],
+    ['package.json', 'dist/index.js'],
+  )
+})
+
+test('parses npm 12 pack JSON output', (t) => {
+  t.deepEqual(
+    [
+      ...parseNpmPackFiles(
+        JSON.stringify({
+          [PACKAGE_NAME]: { files: NPM_PACK_FILES },
+        }),
+      ),
+    ],
+    ['package.json', 'dist/index.js'],
+  )
+})
+
+test('rejects an unexpected npm pack JSON result', (t) => {
+  t.throws(() => parseNpmPackFiles(JSON.stringify({ files: [] })), {
+    message: 'npm pack returned an unexpected JSON result',
+  })
+})

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

@@ -2,7 +2,11 @@ import ava, { type ExecutionContext } from 'ava'
 import { parseSync } from 'oxc-parser'
 
 import { createCjsBinding, createEsmBinding } from '../templates/js-binding.js'
-import { createWasiBrowserBinding } from '../templates/load-wasi-template.js'
+import {
+  createWasiBinding,
+  createWasiBrowserBinding,
+  createWasiDeferredBrowserBinding,
+} from '../templates/load-wasi-template.js'
 import { createWasiBrowserWorkerBinding } from '../templates/wasi-worker-template.js'
 
 const test = ava
@@ -13,6 +17,54 @@ test('createWasiBrowserBinding default', (t) => {
   t.snapshot(createWasiBrowserBinding('test-wasi'))
 })
 
+test('createWasiBrowserBinding threaded builds size worker pools from hardwareConcurrency', (t) => {
+  const binding = createWasiBrowserBinding(
+    'test-wasi',
+    4000,
+    65536,
+    false,
+    false, // asyncInit: false — threaded builds still init asynchronously
+    false,
+    false,
+    true,
+  )
+  t.true(binding.includes('const __asyncWorkPoolSize = 4'))
+  t.true(binding.includes('const __workerPoolSize = Math.max('))
+  t.true(binding.includes('globalThis.navigator?.hardwareConcurrency ?? 4'))
+  // The reuse pool includes the async-work reservation: the async pool
+  // draws from the same reuse pool, so without it exhaustion would starve
+  // addon thread spawns. No `strict`: at exhaustion the fallback worker
+  // boots once the parent returns to its event loop, which is the correct
+  // behavior for spawn-and-return workloads.
+  t.true(
+    binding.includes(
+      'reuseWorker: { size: __asyncWorkPoolSize + __workerPoolSize },',
+    ),
+  )
+  t.false(binding.includes('strict'))
+  t.true(binding.includes('asyncWorkPoolSize: __asyncWorkPoolSize,'))
+  t.true(binding.includes('await __emnapiInstantiateNapiModule('))
+  t.false(binding.includes('__emnapiInstantiateNapiModuleSync(__wasmFile'))
+})
+
+test('createWasiBrowserBinding threadless keeps sync init and no pool', (t) => {
+  const binding = createWasiBrowserBinding(
+    'test-wasi',
+    4000,
+    65536,
+    false,
+    false,
+    false,
+    false,
+    false,
+  )
+  t.false(binding.includes('__workerPoolSize'))
+  t.false(binding.includes('hardwareConcurrency'))
+  t.false(binding.includes('reuseWorker'))
+  t.true(binding.includes('asyncWorkPoolSize: 0,'))
+  t.true(binding.includes('__emnapiInstantiateNapiModuleSync(__wasmFile'))
+})
+
 test('createWasiBrowserBinding with errorEvent', (t) => {
   t.snapshot(
     createWasiBrowserBinding(
@@ -152,6 +204,86 @@ for (const { name, code } of cjsBindingCases) {
   })
 }
 
+// `napi_prepare_wasm_env_cleanup` only *queues* the promise settlements of the
+// tasks it cancels: `napi_call_threadsafe_function` appends to the
+// threadsafe-function queue, and @emnapi/core dispatches that queue from a
+// macrotask two coalescing turns later. `Context.destroy()` then drains the
+// queue with a null env and discards it. Measured against @emnapi/core
+// 2.0.0-alpha.3: zero microtask checkpoints ever deliver the settlement, and it
+// takes exactly two macrotask turns.
+//
+// So a loader that emits the barrier and `destroy()` back to back strands
+// exactly the promises the barrier exists to settle, and it does so silently.
+// `examples/custom-async-runtime` covers the hand-written loader and the two
+// emitted flavors it builds (node cjs threadless, deferred/workerd)
+// behaviorally; the other flavors are never instantiated by any test, so assert
+// the shape here as well.
+const wasiLoaderCases: Array<{ name: string; code: string }> = [
+  { name: 'node cjs', code: createWasiBinding('test', '@scope/test') },
+  {
+    name: 'node cjs threadless',
+    code: createWasiBinding('test', '@scope/test', 4000, 65536, false),
+  },
+  { name: 'browser esm', code: createWasiBrowserBinding('test') },
+  { name: 'deferred/workerd', code: createWasiDeferredBrowserBinding('test') },
+]
+
+for (const { name, code } of wasiLoaderCases) {
+  test(`WASI loader waits for queued settlements before destroy: ${name}`, (t) => {
+    t.true(
+      code.includes('napi_prepare_wasm_env_cleanup'),
+      'loader must run the pre-teardown barrier',
+    )
+    t.true(
+      code.includes('napi_wasm_env_cleanup_pending'),
+      'loader must poll napi_wasm_env_cleanup_pending; without it the barrier queues settlements that Context.destroy() then discards',
+    )
+    t.true(
+      code.includes('__drainWasmEnvCleanup'),
+      'loader must call the settlement drain on its disposal path',
+    )
+    t.true(
+      code.includes('__scheduleMacrotask'),
+      'the drain must yield real macrotask turns; microtask checkpoints never let the emnapi dispatch run',
+    )
+    // Initialization rollback is the same hazard, one step earlier. Registration
+    // runs with a live environment, so a module-init hook can start a task and
+    // *then* return an error; the barrier cancels the task and queues its
+    // rejection, and a rollback that destroys the context in the same turn
+    // discards it — stranding a promise that already escaped into JavaScript.
+    t.true(
+      initializationRollbackBody(code).includes(
+        DRAIN_CALL_BY_ROLLBACK_FLAVOR[
+          code.includes(EAGER_ROLLBACK_SIGNATURE) ? 'eager' : 'deferred'
+        ],
+      ),
+      'initialization rollback must drain queued settlements before destroying the context',
+    )
+  })
+}
+
+const EAGER_ROLLBACK_SIGNATURE = 'function __rollbackWasiInitialization() {'
+const DEFERRED_ROLLBACK_SIGNATURE = "__lifecycleState = 'failed'"
+const DRAIN_CALL_BY_ROLLBACK_FLAVOR = {
+  eager: '__drainWasmEnvCleanup',
+  deferred: '__prepareForDisposal',
+} as const
+
+/**
+ * The body of a loader's initialization-failure path: `__rollbackWasiInitialization`
+ * for the eager loaders, `__createInstance`'s catch for the deferred one.
+ * Sliced rather than searched whole-file, so a drain that only runs on the
+ * ordinary disposal path cannot satisfy the assertion.
+ */
+function initializationRollbackBody(code: string): string {
+  const eagerStart = code.indexOf(EAGER_ROLLBACK_SIGNATURE)
+  if (eagerStart !== -1) {
+    return code.slice(eagerStart, code.indexOf('\n}', eagerStart))
+  }
+  const deferredStart = code.indexOf(DEFERRED_ROLLBACK_SIGNATURE)
+  return code.slice(deferredStart, code.indexOf('throw error', deferredStart))
+}
+
 test('createEsmBinding is Node 12 compatible', (t) => {
   const code = createEsmBinding('test', '@scope/test', ['sum'])
   assertValidJS(t, code, 'esm')

package/src/api/pre-publish.ts

@@ -1691,18 +1691,7 @@ function readNpmPackFiles(packageDir: string, packageDescription: string) {
       maxBuffer: 64 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe'],
     })
-    const packResult = JSON.parse(output) as {
-      files?: { path?: unknown }[]
-    }[]
-    if (!Array.isArray(packResult) || !Array.isArray(packResult[0]?.files)) {
-      throw new Error('npm pack returned an unexpected JSON result')
-    }
-    return new Set(
-      packResult[0].files
-        .map(({ path }) => path)
-        .filter((path): path is string => typeof path === 'string')
-        .map((path) => path.replaceAll('\\', '/').replace(/^\.\//, '')),
-    )
+    return parseNpmPackFiles(output)
   } catch (error) {
     throw new Error(
       `Failed to validate the ${packageDescription} with npm pack --dry-run. Ensure npm is available and the package can be packed.`,
@@ -1711,6 +1700,23 @@ function readNpmPackFiles(packageDir: string, packageDescription: string) {
   }
 }
 
+export function parseNpmPackFiles(output: string) {
+  const parsedResult: unknown = JSON.parse(output)
+  const packResults = Array.isArray(parsedResult)
+    ? parsedResult
+    : Object.values(asRecord(parsedResult) ?? {})
+  const files = asRecord(packResults[0])?.files
+  if (!Array.isArray(files)) {
+    throw new Error('npm pack returned an unexpected JSON result')
+  }
+  return new Set(
+    files
+      .map((file) => asRecord(file)?.path)
+      .filter((path): path is string => typeof path === 'string')
+      .map((path) => path.replaceAll('\\', '/').replace(/^\.\//, '')),
+  )
+}
+
 function validateRootFacadePacklist(
   rootDir: string,
   rootPackageFiles: string[],