@napi-rs/cli 3.6.2 → 3.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@napi-rs/cli",
-  "version": "3.6.2",
+  "version": "3.7.1",
   "description": "Cli tools for napi-rs",
   "author": "LongYinan <lynweklm@gmail.com>",
   "homepage": "https://napi.rs/",
@@ -60,35 +60,35 @@
     "url": "https://github.com/napi-rs/napi-rs/issues"
   },
   "dependencies": {
-    "@inquirer/prompts": "^8.0.0",
+    "@inquirer/prompts": "^8.5.2",
     "@napi-rs/cross-toolchain": "^1.0.3",
     "@napi-rs/wasm-tools": "^1.0.1",
     "@octokit/rest": "^22.0.1",
     "clipanion": "^4.0.0-rc.4",
     "colorette": "^2.0.20",
-    "emnapi": "^1.9.1",
-    "es-toolkit": "^1.41.0",
-    "js-yaml": "^4.1.0",
-    "obug": "^2.0.0",
-    "semver": "^7.7.3",
+    "emnapi": "^1.11.0",
+    "es-toolkit": "^1.47.0",
+    "js-yaml": "^4.2.0",
+    "obug": "^2.1.2",
+    "semver": "^7.8.2",
     "typanion": "^3.14.0"
   },
   "devDependencies": {
-    "@emnapi/runtime": "^1.9.1",
+    "@emnapi/runtime": "^1.11.0",
     "@oxc-node/core": "^0.1.0",
     "@std/toml": "npm:@jsr/std__toml@^1.0.11",
     "@types/inquirer": "^9.0.9",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^24.10.0",
+    "@types/node": "^25.9.2",
     "@types/semver": "^7.7.1",
-    "ava": "^7.0.0",
-    "empathic": "^2.0.0",
+    "ava": "^8.0.1",
+    "empathic": "^2.0.1",
     "env-paths": "^4.0.0",
-    "oxc-parser": "^0.125.0",
-    "prettier": "^3.6.2",
-    "tsdown": "^0.21.0",
+    "oxc-parser": "^0.135.0",
+    "prettier": "^3.8.3",
+    "tsdown": "^0.22.2",
     "tslib": "^2.8.1",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "@emnapi/runtime": "^1.7.1"
@@ -105,12 +105,12 @@
   "scripts": {
     "codegen": "node --import @oxc-node/core/register ./codegen/index.ts",
     "build": "tsdown",
-    "test": "node --import @oxc-node/core/register ../node_modules/ava/entrypoints/cli.mjs"
+    "test": "node --import @oxc-node/core/register ../node_modules/ava/entrypoints/cli.js"
   },
   "ava": {
-    "extensions": {
-      "ts": "module"
-    },
+    "extensions": [
+      "ts"
+    ],
     "timeout": "2m",
     "workerThreads": false,
     "files": [

package/src/api/build.ts

@@ -874,6 +874,8 @@ class Builder {
       configDtsHeader: this.config.dtsHeader,
       configDtsHeaderFile: this.config.dtsHeaderFile,
       constEnum: this.options.constEnum ?? this.config.constEnum,
+      runtimeStringEnum:
+        this.options.runtimeStringEnum ?? this.config.runtimeStringEnum,
       cwd: this.options.cwd,
     })
 
@@ -1050,9 +1052,16 @@ export interface GenerateTypeDefOptions {
   configDtsHeader?: string
   configDtsHeaderFile?: string
   constEnum?: boolean
+  runtimeStringEnum?: boolean
   cwd: string
 }
 
+/**
+ * Walk the napi-derive intermediate type-def directory, render every entry
+ * into TypeScript via {@link processTypeDef}, and return the concatenated
+ * `.d.ts` source plus the list of identifiers to re-export from
+ * `index.js`.
+ */
 export async function generateTypeDef(
   options: GenerateTypeDefOptions,
 ): Promise<{ exports: string[]; dts: string }> {
@@ -1097,11 +1106,20 @@ export async function generateTypeDef(
     .filter((file) => file.isFile())
     .sort((a, b) => a.name.localeCompare(b.name))
 
+  const constEnum = options.constEnum ?? true
+  const runtimeStringEnum = options.runtimeStringEnum ?? false
+  if (runtimeStringEnum && constEnum) {
+    debug.warn(
+      '`--runtime-string-enum` has no effect when `--const-enum` is enabled (the default). Pass `--no-const-enum` to activate runtime string enum emission.',
+    )
+  }
+
   const processedTypeDefs = await Promise.all(
     typeDefFiles.map((file) =>
       processTypeDef(
         join(options.typeDefDir, file.name),
-        options.constEnum ?? true,
+        constEnum,
+        runtimeStringEnum,
       ),
     ),
   )

package/src/api/new.ts

@@ -193,7 +193,7 @@ async function updateCargoTomlTypeDef(
       ? { version: napiDeriveDependency }
       : { ...napiDeriveDependency }
 
-  const existingFeatures = Array.isArray(dependencyConfig.features)
+  const existingFeatures: string[] = Array.isArray(dependencyConfig.features)
     ? dependencyConfig.features.filter(
         (feature: unknown): feature is string => typeof feature === 'string',
       )

package/src/api/templates/js-binding.ts

@@ -227,23 +227,33 @@ function requireNative() {
 
 nativeBinding = requireNative()
 
-if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → force WASI fallback even if native loaded
+//   'error'                  → force WASI and throw if no WASI binding is found
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' || process.env.NAPI_RS_FORCE_WASI === 'error'
+
+if (!nativeBinding || forceWasi) {
   let wasiBinding = null
   let wasiBindingError = null
   try {
     wasiBinding = require('./${localName}.wasi.cjs')
     nativeBinding = wasiBinding
   } catch (err) {
-    if (process.env.NAPI_RS_FORCE_WASI) {
+    if (forceWasi) {
       wasiBindingError = err
     }
   }
-  if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  if (!nativeBinding || forceWasi) {
     try {
       wasiBinding = require('${pkgName}-wasm32-wasi')
       nativeBinding = wasiBinding
     } catch (err) {
-      if (process.env.NAPI_RS_FORCE_WASI) {
+      if (forceWasi) {
         if (!wasiBindingError) {
           wasiBindingError = err
         } else {

package/src/api/templates/load-wasi-template.ts

@@ -34,7 +34,7 @@ const __wasi = new __WASI({
     : ''
 
   const workerErrorHandler = errorEvent
-    ? `    worker.addEventListener('error', (event) => {
+    ? `    worker.addEventListener('message', (event) => {
       if (event.data && typeof event.data === 'object' && event.data.type === 'error') {
         window.dispatchEvent(new CustomEvent('napi-rs-worker-error', { detail: event.data }))
       }

package/src/api/templates/wasi-worker-template.ts

@@ -109,10 +109,9 @@ const fs = createFsProxy(__memfsExported)`
     errorOutputs.length = 0
   }`
     : ''
+  const errorOutputsDecl = errorEvent ? `\nconst errorOutputs = []\n` : ''
   return `${fsImport}
-
-const errorOutputs = []
-
+${errorOutputsDecl}
 const handler = new MessageHandler({
   onLoad({ wasmModule, wasmMemory }) {
     ${wasiCreation}

package/src/api/universalize.ts

@@ -12,14 +12,32 @@ import { UniArchsByPlatform } from '../utils/target.js'
 
 const debug = debugFactory('universalize')
 
+function createDarwinUniversalBinary(inputs: string[], output: string) {
+  const result = spawnSync('lipo', ['-create', '-output', output, ...inputs], {
+    stdio: 'inherit',
+  })
+
+  if (result.error) {
+    throw result.error
+  }
+
+  if (result.signal) {
+    throw new Error(
+      `Failed to create universal binary '${output}': lipo terminated with signal ${result.signal}.`,
+    )
+  }
+
+  if (result.status !== 0) {
+    throw new Error(
+      `Failed to create universal binary '${output}': lipo exited with status ${result.status}.`,
+    )
+  }
+}
+
 const universalizers: Partial<
   Record<NodeJS.Platform, (inputs: string[], output: string) => void>
 > = {
-  darwin: (inputs, output) => {
-    spawnSync('lipo', ['-create', '-output', output, ...inputs], {
-      stdio: 'inherit',
-    })
-  },
+  darwin: createDarwinUniversalBinary,
 }
 
 export async function universalizeBinaries(userOptions: UniversalizeOptions) {
@@ -77,5 +95,9 @@ export async function universalizeBinaries(userOptions: UniversalizeOptions) {
 
   universalizers[process.platform]?.(srcFiles, output)
 
+  if (!(await fileExists(output))) {
+    throw new Error(`Universal binary was not created: ${output}`)
+  }
+
   debug(`Produced universal binary: ${output}`)
 }

package/src/def/build.ts

@@ -55,6 +55,11 @@ export abstract class BaseBuildCommand extends Command {
     description: 'Whether generate const enum for typescript bindings',
   })
 
+  runtimeStringEnum?: boolean = Option.Boolean('--runtime-string-enum', {
+    description:
+      'Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.',
+  })
+
   jsBinding?: string = Option.String('--js', {
     description:
       'Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.',
@@ -157,6 +162,7 @@ export abstract class BaseBuildCommand extends Command {
       platform: this.platform,
       jsPackageName: this.jsPackageName,
       constEnum: this.constEnum,
+      runtimeStringEnum: this.runtimeStringEnum,
       jsBinding: this.jsBinding,
       noJsBinding: this.noJsBinding,
       dts: this.dts,
@@ -225,6 +231,10 @@ export interface BuildOptions {
    * Whether generate const enum for typescript bindings
    */
   constEnum?: boolean
+  /**
+   * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.
+   */
+  runtimeStringEnum?: boolean
   /**
    * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.
    */

package/src/utils/config.ts

@@ -42,6 +42,11 @@ export interface UserNapiConfig {
    */
   constEnum?: boolean
 
+  /**
+   * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.
+   */
+  runtimeStringEnum?: boolean
+
   /**
    * dts header prepend to the generated dts file
    */
@@ -155,7 +160,10 @@ export interface CommonPackageJsonFields {
 export type NapiConfig = Required<
   Pick<UserNapiConfig, 'binaryName' | 'packageName' | 'npmClient'>
 > &
-  Pick<UserNapiConfig, 'wasm' | 'dtsHeader' | 'dtsHeaderFile' | 'constEnum'> & {
+  Pick<
+    UserNapiConfig,
+    'wasm' | 'dtsHeader' | 'dtsHeaderFile' | 'constEnum' | 'runtimeStringEnum'
+  > & {
     targets: Target[]
     packageJson: CommonPackageJsonFields
   }

package/src/utils/typegen.ts

@@ -29,9 +29,26 @@ interface TypeDefLine {
   js_mod?: string
 }
 
+/**
+ * Render a single intermediate type-def line as the TypeScript source it
+ * should produce in `index.d.ts`.
+ *
+ * @param line - The intermediate type-def entry to render.
+ * @param constEnum - When true, emit numeric and string `#[napi]` enums as
+ *   `const enum`. When false (`--no-const-enum`), numeric enums become
+ *   regular runtime enums and string enums fall back to a type-only union
+ *   unless `runtimeStringEnum` is also true.
+ * @param runtimeStringEnum - When true under `--no-const-enum`, emit
+ *   `#[napi(string_enum)]` as a runtime enum (`export declare enum`)
+ *   instead of a type-only union. No-op when `constEnum` is true.
+ * @param ident - Indentation level applied to the rendered output.
+ * @param ambient - When true, emit declarations in the ambient form used
+ *   inside `declare namespace` blocks (e.g. drop the `declare` keyword).
+ */
 function prettyPrint(
   line: TypeDefLine,
   constEnum: boolean,
+  runtimeStringEnum: boolean,
   ident: number,
   ambient = false,
 ): string {
@@ -45,18 +62,22 @@ function prettyPrint(
       s += `export type ${line.name} = \n${line.def}`
       break
 
-    case TypeDefKind.Enum:
+    case TypeDefKind.Enum: {
       const enumName = constEnum ? 'const enum' : 'enum'
       s += `${exportDeclare(ambient)} ${enumName} ${line.name} {\n${line.def}\n}`
       break
+    }
 
-    case TypeDefKind.StringEnum:
+    case TypeDefKind.StringEnum: {
       if (constEnum) {
         s += `${exportDeclare(ambient)} const enum ${line.name} {\n${line.def}\n}`
+      } else if (runtimeStringEnum) {
+        s += `${exportDeclare(ambient)} enum ${line.name} {\n${line.def}\n}`
       } else {
         s += `export type ${line.name} = ${line.def.replaceAll(/.*=/g, '').replaceAll(',', '|')};`
       }
       break
+    }
 
     case TypeDefKind.Struct:
       const extendsDef = line.extends ? ` extends ${line.extends}` : ''
@@ -97,9 +118,20 @@ function exportDeclare(ambient: boolean): string {
   return 'export declare'
 }
 
+/**
+ * Read the napi-derive-emitted intermediate type-def file and render its
+ * entries into the `index.d.ts` source string plus the list of names to
+ * re-export from `index.js`.
+ *
+ * @param intermediateTypeFile - Path to the JSONL type-def file produced
+ *   by napi-derive (one entry per `#[napi]` item).
+ * @param constEnum - See {@link prettyPrint}.
+ * @param runtimeStringEnum - See {@link prettyPrint}. Defaults to `false`.
+ */
 export async function processTypeDef(
   intermediateTypeFile: string,
   constEnum: boolean,
+  runtimeStringEnum: boolean = false,
 ) {
   const exports: string[] = []
   const defs = await readIntermediateTypeFile(intermediateTypeFile)
@@ -126,7 +158,7 @@ export async function processTypeDef(
                 default:
                   break
               }
-              return prettyPrint(def, constEnum, 0)
+              return prettyPrint(def, constEnum, runtimeStringEnum, 0)
             })
             .join('\n\n')
         } else {
@@ -134,7 +166,8 @@ export async function processTypeDef(
           let declaration = ''
           declaration += `export declare namespace ${namespace} {\n`
           for (const def of defs) {
-            declaration += prettyPrint(def, constEnum, 2, true) + '\n'
+            declaration +=
+              prettyPrint(def, constEnum, runtimeStringEnum, 2, true) + '\n'
           }
           declaration += '}'
           return declaration