@napi-rs/cli 3.6.1 → 3.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@napi-rs/cli",
-  "version": "3.6.1",
+  "version": "3.7.0",
   "description": "Cli tools for napi-rs",
   "author": "LongYinan <lynweklm@gmail.com>",
   "homepage": "https://napi.rs/",
@@ -66,7 +66,7 @@
     "@octokit/rest": "^22.0.1",
     "clipanion": "^4.0.0-rc.4",
     "colorette": "^2.0.20",
-    "emnapi": "^1.9.1",
+    "emnapi": "^1.10.0",
     "es-toolkit": "^1.41.0",
     "js-yaml": "^4.1.0",
     "obug": "^2.0.0",
@@ -81,14 +81,14 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.10.0",
     "@types/semver": "^7.7.1",
-    "ava": "^7.0.0",
+    "ava": "^8.0.0",
     "empathic": "^2.0.0",
     "env-paths": "^4.0.0",
-    "oxc-parser": "^0.124.0",
+    "oxc-parser": "^0.133.0",
     "prettier": "^3.6.2",
-    "tsdown": "^0.21.0",
+    "tsdown": "^0.22.0",
     "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

@@ -542,7 +542,7 @@ class Builder {
       require.resolve('emnapi'),
       '..',
       'lib',
-      'wasm32-wasi-threads',
+      'wasm32-wasip1-threads',
     )
     this.envs.EMNAPI_LINK_DIR = emnapi
     const emnapiVersion = require('emnapi/package.json').version
@@ -593,15 +593,15 @@ class Builder {
       )
       this.setEnvIfNotExists(
         'TARGET_CFLAGS',
-        `--target=wasm32-wasi-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj`,
+        `--target=wasm32-wasip1-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj`,
       )
       this.setEnvIfNotExists(
         'TARGET_CXXFLAGS',
-        `--target=wasm32-wasi-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj`,
+        `--target=wasm32-wasip1-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj`,
       )
       this.setEnvIfNotExists(
         `TARGET_LDFLAGS`,
-        `-fuse-ld=${WASI_SDK_PATH}/bin/wasm-ld --target=wasm32-wasi-threads`,
+        `-fuse-ld=${WASI_SDK_PATH}/bin/wasm-ld --target=wasm32-wasip1-threads`,
       )
     }
   }
@@ -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 }> {
@@ -1093,20 +1102,31 @@ export async function generateTypeDef(
     return { exports: [], dts: '' }
   }
 
-  for (const file of files) {
-    if (!file.isFile()) {
-      continue
-    }
+  const typeDefFiles = files
+    .filter((file) => file.isFile())
+    .sort((a, b) => a.name.localeCompare(b.name))
 
-    const { dts: fileDts, exports: fileExports } = await processTypeDef(
-      join(options.typeDefDir, file.name),
-      options.constEnum ?? true,
+  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.',
     )
-
-    dts += fileDts
-    exports.push(...fileExports)
   }
 
+  const processedTypeDefs = await Promise.all(
+    typeDefFiles.map((file) =>
+      processTypeDef(
+        join(options.typeDefDir, file.name),
+        constEnum,
+        runtimeStringEnum,
+      ),
+    ),
+  )
+
+  dts = processedTypeDefs.map(({ dts }) => dts).join('')
+  exports = processedTypeDefs.flatMap(({ exports }) => exports)
+
   if (dts.indexOf('ExternalObject<') > -1) {
     header += `
 export declare class ExternalObject<T> {

package/src/api/create-npm-dirs.ts

@@ -1,9 +1,10 @@
 import { createRequire } from 'node:module'
 import { join, resolve } from 'node:path'
 
-import { parse } from 'semver'
+import { Comparator, Range, minVersion, subset } from 'semver'
 
 const require = createRequire(import.meta.url)
+const minimumWasiNodeVersion = '>=14.0.0'
 
 import {
   applyDefaultCreateNpmDirsOptions,
@@ -156,23 +157,11 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
         `wasi-worker.mjs`,
         `wasi-worker-browser.mjs`,
       )
-      let needRestrictNodeVersion = true
-      if (scopedPackageJson.engines?.node) {
-        try {
-          const { major } = parse(scopedPackageJson.engines.node) ?? {
-            major: 0,
-          }
-          if (major >= 14) {
-            needRestrictNodeVersion = false
-          }
-        } catch {
-          // ignore
-        }
-      }
-      if (needRestrictNodeVersion) {
-        scopedPackageJson.engines = {
-          node: '>=14.0.0',
-        }
+      scopedPackageJson.engines = {
+        ...scopedPackageJson.engines,
+        node: scopedPackageJson.engines?.node
+          ? restrictWasiNodeEngine(scopedPackageJson.engines.node)
+          : minimumWasiNodeVersion,
       }
       const emnapiVersion = require('emnapi/package.json').version
       scopedPackageJson.dependencies = {
@@ -206,3 +195,69 @@ function readme(packageName: string, target: Target) {
 This is the **${target.triple}** binary for \`${packageName}\`
 `
 }
+
+function restrictWasiNodeEngine(nodeRange: string) {
+  try {
+    if (subset(nodeRange, minimumWasiNodeVersion)) {
+      return nodeRange
+    }
+
+    if (subset(minimumWasiNodeVersion, nodeRange)) {
+      return minimumWasiNodeVersion
+    }
+
+    const minimumComparator = new Comparator(minimumWasiNodeVersion)
+    const restrictedRangeSets = new Range(nodeRange).set
+      .map((comparators) =>
+        normalizeComparatorSet([...comparators, minimumComparator]),
+      )
+      .filter(
+        (candidate): candidate is string =>
+          candidate !== undefined && minVersion(candidate) !== null,
+      )
+
+    if (restrictedRangeSets.length > 0) {
+      return restrictedRangeSets.join(' || ')
+    }
+  } catch {
+    // ignore
+  }
+
+  return minimumWasiNodeVersion
+}
+
+function normalizeComparatorSet(comparators: Comparator[]) {
+  const exactMatch = comparators.find(({ operator }) => operator === '')
+  if (exactMatch) {
+    return comparators.every((comparator) => comparator.test(exactMatch.semver))
+      ? exactMatch.value
+      : undefined
+  }
+
+  let lowerBound: Comparator | undefined
+  let upperBound: Comparator | undefined
+
+  for (const comparator of comparators) {
+    if (comparator.operator === '>' || comparator.operator === '>=') {
+      if (
+        !lowerBound ||
+        comparator.semver.compare(lowerBound.semver) > 0 ||
+        (comparator.semver.compare(lowerBound.semver) === 0 &&
+          comparator.operator === '>')
+      ) {
+        lowerBound = comparator
+      }
+    } else if (comparator.operator === '<' || comparator.operator === '<=') {
+      if (
+        !upperBound ||
+        comparator.semver.compare(upperBound.semver) < 0 ||
+        (comparator.semver.compare(upperBound.semver) === 0 &&
+          comparator.operator === '<')
+      ) {
+        upperBound = comparator
+      }
+    }
+  }
+
+  return [lowerBound?.value, upperBound?.value].filter(Boolean).join(' ')
+}

package/src/api/new.ts

@@ -4,6 +4,7 @@ import { homedir } from 'node:os'
 import path from 'node:path'
 import { promises as fs } from 'node:fs'
 
+import { parse as parseToml, stringify as stringifyToml } from '@std/toml'
 import { load as yamlLoad, dump as yamlDump } from 'js-yaml'
 
 import {
@@ -15,6 +16,7 @@ import {
   debugFactory,
   DEFAULT_TARGETS,
   mkdirAsync,
+  parseTriple,
   readdirAsync,
   statAsync,
   type SupportedPackageManager,
@@ -33,6 +35,8 @@ const TEMPLATE_REPOS = {
   pnpm: 'https://github.com/napi-rs/package-template-pnpm',
 } as const
 
+const WASI_TARGET = 'wasm32-wasip1-threads'
+
 async function checkGitCommand(): Promise<boolean> {
   return new Promise<boolean>((resolve) => {
     const cp = exec('git --version')
@@ -125,7 +129,7 @@ async function copyDirectory(
           entry.name.endsWith('.wasi.cjs') ||
           entry.name.endsWith('wasi-worker-browser.mjs') ||
           entry.name.endsWith('wasi-worker.mjs') ||
-          entry.name.endsWith('browser.js'))
+          entry.name === 'browser.js')
       ) {
         continue
       }
@@ -140,6 +144,7 @@ async function filterTargetsInPackageJson(
 ): Promise<void> {
   const content = await fs.readFile(filePath, 'utf-8')
   const packageJson = JSON.parse(content)
+  const includeWasiBindings = enabledTargets.includes(WASI_TARGET)
 
   // Filter napi.targets
   if (packageJson.napi?.targets) {
@@ -148,9 +153,63 @@ async function filterTargetsInPackageJson(
     )
   }
 
+  if (!includeWasiBindings) {
+    if (
+      packageJson.browser === 'browser.js' ||
+      packageJson.browser === './browser.js'
+    ) {
+      delete packageJson.browser
+    }
+
+    if (Array.isArray(packageJson.files)) {
+      packageJson.files = packageJson.files.filter(
+        (file: unknown) => file !== 'browser.js' && file !== './browser.js',
+      )
+    }
+  }
+
   await fs.writeFile(filePath, JSON.stringify(packageJson, null, 2) + '\n')
 }
 
+async function updateCargoTomlTypeDef(
+  filePath: string,
+  enableTypeDef: boolean,
+): Promise<void> {
+  if (enableTypeDef) {
+    return
+  }
+
+  const content = await fs.readFile(filePath, 'utf-8')
+  const cargoToml = parseToml(content) as Record<string, any>
+  const dependencies = cargoToml.dependencies
+
+  if (!dependencies || !dependencies['napi-derive']) {
+    return
+  }
+
+  const napiDeriveDependency = dependencies['napi-derive']
+  const dependencyConfig =
+    typeof napiDeriveDependency === 'string'
+      ? { version: napiDeriveDependency }
+      : { ...napiDeriveDependency }
+
+  const existingFeatures: string[] = Array.isArray(dependencyConfig.features)
+    ? dependencyConfig.features.filter(
+        (feature: unknown): feature is string => typeof feature === 'string',
+      )
+    : []
+
+  dependencyConfig['default-features'] = false
+  dependencyConfig.features = [
+    'strict',
+    ...existingFeatures.filter((feature) => feature !== 'strict'),
+  ].filter((feature) => feature !== 'type-def')
+
+  dependencies['napi-derive'] = dependencyConfig
+
+  await fs.writeFile(filePath, stringifyToml(cargoToml))
+}
+
 async function filterTargetsInGithubActions(
   filePath: string,
   enabledTargets: string[],
@@ -158,13 +217,6 @@ async function filterTargetsInGithubActions(
   const content = await fs.readFile(filePath, 'utf-8')
   const yaml = yamlLoad(content) as any
 
-  const macOSAndWindowsTargets = new Set([
-    'x86_64-pc-windows-msvc',
-    'x86_64-pc-windows-gnu',
-    'aarch64-pc-windows-msvc',
-    'x86_64-apple-darwin',
-  ])
-
   const linuxTargets = new Set([
     'x86_64-unknown-linux-gnu',
     'x86_64-unknown-linux-musl',
@@ -184,6 +236,10 @@ async function filterTargetsInGithubActions(
   const hasLinuxTargets = enabledTargets.some((target) =>
     linuxTargets.has(target),
   )
+  const hasMacOSOrWindowsTargets = enabledTargets.some((target) => {
+    const platform = parseTriple(target).platform
+    return platform === 'darwin' || platform === 'win32'
+  })
 
   // Filter the matrix configurations in the build job
   if (yaml?.jobs?.build?.strategy?.matrix?.settings) {
@@ -198,7 +254,7 @@ async function filterTargetsInGithubActions(
 
   const jobsToRemove: string[] = []
 
-  if (enabledTargets.every((target) => !macOSAndWindowsTargets.has(target))) {
+  if (!hasMacOSOrWindowsTargets) {
     jobsToRemove.push('test-macOS-windows-binding')
   } else {
     // Filter the matrix configurations in the test-macOS-windows-binding job
@@ -237,7 +293,7 @@ async function filterTargetsInGithubActions(
     }
   }
 
-  if (!enabledTargets.includes('wasm32-wasip1-threads')) {
+  if (!enabledTargets.includes(WASI_TARGET)) {
     jobsToRemove.push('test-wasi')
   }
 
@@ -313,11 +369,9 @@ function processOptions(options: RawNewOptions) {
     const out = execSync(`rustup target list`, {
       encoding: 'utf8',
     })
-    if (out.includes('wasm32-wasip1-threads')) {
+    if (out.includes(WASI_TARGET)) {
       options.targets = options.targets.map((target) =>
-        target === 'wasm32-wasi-preview1-threads'
-          ? 'wasm32-wasip1-threads'
-          : target,
+        target === 'wasm32-wasi-preview1-threads' ? WASI_TARGET : target,
       )
     }
   }
@@ -357,7 +411,7 @@ export async function newProject(userOptions: RawNewOptions) {
       await copyDirectory(
         templatePath,
         options.path,
-        options.targets.includes('wasm32-wasip1-threads'),
+        options.targets.includes(WASI_TARGET),
       )
 
       // Rename project using the rename API
@@ -367,6 +421,11 @@ export async function newProject(userOptions: RawNewOptions) {
         binaryName: getBinaryName(options.name),
       })
 
+      const cargoTomlPath = path.join(options.path, 'Cargo.toml')
+      if (existsSync(cargoTomlPath)) {
+        await updateCargoTomlTypeDef(cargoTomlPath, options.enableTypeDef)
+      }
+
       // Filter targets in package.json
       const packageJsonPath = path.join(options.path, 'package.json')
       if (existsSync(packageJsonPath)) {

package/src/api/pre-publish.ts

@@ -85,6 +85,7 @@ export async function prePublish(userOptions: PrePublishOptions) {
 
   function getRepoInfo(packageName: string, version: string) {
     const headCommit = execSync('git log -1 --pretty=%B', {
+      cwd: options.cwd,
       encoding: 'utf-8',
     }).trim()
 

package/src/api/rename.ts

@@ -41,6 +41,18 @@ export async function renameProject(userOptions: RenameOptions) {
     },
   )
 
+  if (options.repository) {
+    if (
+      packageJsonData.repository &&
+      typeof packageJsonData.repository === 'object' &&
+      !Array.isArray(packageJsonData.repository)
+    ) {
+      packageJsonData.repository.url = options.repository
+    } else {
+      packageJsonData.repository = options.repository
+    }
+  }
+
   if (options.configPath) {
     const configPath = resolve(options.cwd, options.configPath)
     const configContent = await readFileAsync(configPath, 'utf8')

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

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process'
-import { join, resolve } from 'node:path'
+import { resolve } from 'node:path'
 
 import {
   applyDefaultUniversalizeOptions,
@@ -12,20 +12,38 @@ 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) {
   const options = applyDefaultUniversalizeOptions(userOptions)
 
-  const packageJsonPath = join(options.cwd, options.packageJsonPath)
+  const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
 
   const config = await readNapiConfig(
     packageJsonPath,
@@ -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/commands/build.ts

@@ -35,6 +35,7 @@ export class BuildCommand extends BaseBuildCommand {
         } catch (e) {
           debug.error(`Failed to pipe output file ${output.path} to command`)
           debug.error(e)
+          throw e
         }
       }
     }

package/src/commands/new.ts

@@ -11,10 +11,20 @@ import {
   DEFAULT_TARGETS,
   type TargetTriple,
 } from '../utils/index.js'
-import { napiEngineRequirement } from '../utils/version.js'
+import {
+  napiEngineRequirement,
+  SUPPORTED_NAPI_VERSIONS,
+} from '../utils/version.js'
 
 const debug = debugFactory('new')
 
+export function getNapiVersionChoices() {
+  return SUPPORTED_NAPI_VERSIONS.map((version) => ({
+    name: `napi${version} (${napiEngineRequirement(version)})`,
+    value: version,
+  }))
+}
+
 export class NewCommand extends BaseNewCommand {
   interactive = Option.Boolean('--interactive,-i', true, {
     description:
@@ -77,10 +87,7 @@ export class NewCommand extends BaseNewCommand {
       message: 'Minimum node-api version (with node version requirement)',
       loop: false,
       pageSize: 10,
-      choices: Array.from({ length: 8 }, (_, i) => ({
-        name: `napi${i + 1} (${napiEngineRequirement(i + 1)})`,
-        value: i + 1,
-      })),
+      choices: getNapiVersionChoices(),
       // choice index
       default: this.minNodeApiVersion - 1,
     })

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`.
    */