@napi-rs/cli 3.0.0-alpha.9 → 3.0.0-alpha.90

package/src/api/build.ts

@@ -1,10 +1,12 @@
 import { spawn } from 'node:child_process'
 import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, rmSync } from 'node:fs'
 import { createRequire } from 'node:module'
-import { tmpdir } from 'node:os'
+import { homedir } from 'node:os'
 import { parse, join, resolve } from 'node:path'
 
 import * as colors from 'colorette'
+import { include as setjmpInclude, lib as setjmpLib } from 'wasm-sjlj'
 
 import { BuildOptions as RawBuildOptions } from '../def/build.js'
 import {
@@ -28,36 +30,45 @@ import {
   tryInstallCargoBinary,
   unlinkAsync,
   writeFileAsync,
+  dirExistsAsync,
+  readdirAsync,
+  CargoWorkspaceMetadata,
 } from '../utils/index.js'
 
-import { createWasiBinding } from './load-wasi-template.js'
-import { createCjsBinding } from './templates/index.js'
-import { WASI_WORKER_TEMPLATE } from './wasi-worker-template.js'
+import { createCjsBinding, createEsmBinding } from './templates/index.js'
+import {
+  createWasiBinding,
+  createWasiBrowserBinding,
+} from './templates/load-wasi-template.js'
+import {
+  createWasiBrowserWorkerBinding,
+  WASI_WORKER_TEMPLATE,
+} from './templates/wasi-worker-template.js'
 
 const debug = debugFactory('build')
 const require = createRequire(import.meta.url)
 
 type OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm'
-type Output = {
-  kind: OutputKind
-  path: string
-}
+type Output = { kind: OutputKind; path: string }
 
-type BuildOptions = RawBuildOptions & {
-  cargoOptions?: string[]
-}
+type BuildOptions = RawBuildOptions & { cargoOptions?: string[] }
+type ParsedBuildOptions = Omit<BuildOptions, 'cwd'> & { cwd: string }
 
-export async function buildProject(options: BuildOptions) {
-  debug('napi build command receive options: %O', options)
+export async function buildProject(rawOptions: BuildOptions) {
+  debug('napi build command receive options: %O', rawOptions)
 
-  const cwd = options.cwd ?? process.cwd()
+  const options: ParsedBuildOptions = {
+    dtsCache: true,
+    ...rawOptions,
+    cwd: rawOptions.cwd ?? process.cwd(),
+  }
 
-  const resolvePath = (...paths: string[]) => resolve(cwd, ...paths)
+  const resolvePath = (...paths: string[]) => resolve(options.cwd, ...paths)
 
   const manifestPath = resolvePath(options.manifestPath ?? 'Cargo.toml')
-  const metadata = parseMetadata(manifestPath)
+  const metadata = await parseMetadata(manifestPath)
 
-  const pkg = metadata.packages.find((p) => {
+  const crate = metadata.packages.find((p) => {
     // package with given name
     if (options.package) {
       return p.name === options.package
@@ -66,33 +77,20 @@ export async function buildProject(options: BuildOptions) {
     }
   })
 
-  if (!pkg) {
+  if (!crate) {
     throw new Error(
       'Unable to find crate to build. It seems you are trying to build a crate in a workspace, try using `--package` option to specify the package to build.',
     )
   }
-
-  const crateDir = parse(pkg.manifest_path).dir
-
-  const builder = new Builder(
-    options,
-    pkg,
-    cwd,
-    options.target
-      ? parseTriple(options.target)
-      : process.env.CARGO_BUILD_TARGET
-        ? parseTriple(process.env.CARGO_BUILD_TARGET)
-        : getSystemDefaultTarget(),
-    crateDir,
-    resolvePath(options.outputDir ?? crateDir),
-    options.targetDir ??
-      process.env.CARGO_BUILD_TARGET_DIR ??
-      metadata.target_directory,
-    await readNapiConfig(
-      resolvePath(options.packageJsonPath ?? 'package.json'),
+  const config = await readNapiConfig(
+    resolvePath(
+      options.configPath ?? options.packageJsonPath ?? 'package.json',
     ),
+    options.configPath ? resolvePath(options.configPath) : undefined,
   )
 
+  const builder = new Builder(metadata, crate, config, options)
+
   return builder.build()
 }
 
@@ -101,16 +99,57 @@ class Builder {
   private readonly envs: Record<string, string> = {}
   private readonly outputs: Output[] = []
 
+  private readonly target: Target
+  private readonly crateDir: string
+  private readonly outputDir: string
+  private readonly targetDir: string
+  private readonly enableTypeDef: boolean = false
+
   constructor(
-    private readonly options: BuildOptions,
+    private readonly metadata: CargoWorkspaceMetadata,
     private readonly crate: Crate,
-    private readonly cwd: string,
-    private readonly target: Target,
-    private readonly crateDir: string,
-    private readonly outputDir: string,
-    private readonly targetDir: string,
     private readonly config: NapiConfig,
-  ) {}
+    private readonly options: ParsedBuildOptions,
+  ) {
+    this.target = options.target
+      ? parseTriple(options.target)
+      : process.env.CARGO_BUILD_TARGET
+        ? parseTriple(process.env.CARGO_BUILD_TARGET)
+        : getSystemDefaultTarget()
+    this.crateDir = parse(crate.manifest_path).dir
+    this.outputDir = resolve(
+      this.options.cwd,
+      options.outputDir ?? this.crateDir,
+    )
+    this.targetDir =
+      options.targetDir ??
+      process.env.CARGO_BUILD_TARGET_DIR ??
+      metadata.target_directory
+    this.enableTypeDef = this.crate.dependencies.some(
+      (dep) =>
+        dep.name === 'napi-derive' &&
+        (dep.uses_default_features || dep.features.includes('type-def')),
+    )
+
+    if (!this.enableTypeDef) {
+      const requirementWarning =
+        '`napi-derive` crate is not used or `type-def` feature is not enabled for `napi-derive` crate'
+      debug.warn(
+        `${requirementWarning}. Will skip binding generation for \`.node\`, \`.wasi\` and \`.d.ts\` files.`,
+      )
+
+      if (
+        this.options.dts ||
+        this.options.dtsHeader ||
+        this.config.dtsHeader ||
+        this.config.dtsHeaderFile
+      ) {
+        debug.warn(
+          `${requirementWarning}. \`dts\` related options are enabled but will be ignored.`,
+        )
+      }
+    }
+  }
 
   get cdyLibName() {
     return this.crate.targets.find((t) => t.crate_types.includes('cdylib'))
@@ -143,11 +182,138 @@ class Builder {
       .setPackage()
       .setFeatures()
       .setTarget()
+      .pickCrossToolchain()
       .setEnvs()
       .setBypassArgs()
       .exec()
   }
 
+  private pickCrossToolchain() {
+    if (!this.options.useNapiCross) {
+      return this
+    }
+    if (this.options.useCross) {
+      debug.warn(
+        'You are trying to use both `--cross` and `--use-napi-cross` options, `--use-cross` will be ignored.',
+      )
+    }
+
+    if (this.options.crossCompile) {
+      debug.warn(
+        'You are trying to use both `--cross-compile` and `--use-napi-cross` options, `--cross-compile` will be ignored.',
+      )
+    }
+
+    try {
+      const { version, download } = require('@napi-rs/cross-toolchain')
+
+      const alias: Record<string, string> = {
+        's390x-unknown-linux-gnu': 's390x-ibm-linux-gnu',
+      }
+
+      const toolchainPath = join(
+        homedir(),
+        '.napi-rs',
+        'cross-toolchain',
+        version,
+        this.target.triple,
+      )
+      mkdirSync(toolchainPath, { recursive: true })
+      if (existsSync(join(toolchainPath, 'package.json'))) {
+        debug(`Toolchain ${toolchainPath} exists, skip extracting`)
+      } else {
+        const tarArchive = download(process.arch, this.target.triple)
+        tarArchive.unpack(toolchainPath)
+      }
+      const upperCaseTarget = targetToEnvVar(this.target.triple)
+      const crossTargetName = alias[this.target.triple] ?? this.target.triple
+      const linkerEnv = `CARGO_TARGET_${upperCaseTarget}_LINKER`
+      this.envs[linkerEnv] = join(
+        toolchainPath,
+        'bin',
+        `${crossTargetName}-gcc`,
+      )
+      if (!process.env.TARGET_SYSROOT) {
+        this.envs[`TARGET_SYSROOT`] = join(
+          toolchainPath,
+          crossTargetName,
+          'sysroot',
+        )
+      }
+      if (!process.env.TARGET_AR) {
+        this.envs[`TARGET_AR`] = join(
+          toolchainPath,
+          'bin',
+          `${crossTargetName}-ar`,
+        )
+      }
+      if (!process.env.TARGET_RANLIB) {
+        this.envs[`TARGET_RANLIB`] = join(
+          toolchainPath,
+          'bin',
+          `${crossTargetName}-ranlib`,
+        )
+      }
+      if (!process.env.TARGET_READELF) {
+        this.envs[`TARGET_READELF`] = join(
+          toolchainPath,
+          'bin',
+          `${crossTargetName}-readelf`,
+        )
+      }
+      if (!process.env.TARGET_C_INCLUDE_PATH) {
+        this.envs[`TARGET_C_INCLUDE_PATH`] = join(
+          toolchainPath,
+          crossTargetName,
+          'sysroot',
+          'usr',
+          'include/',
+        )
+      }
+      if (!process.env.CC && !process.env.TARGET_CC) {
+        this.envs[`CC`] = join(toolchainPath, 'bin', `${crossTargetName}-gcc`)
+        this.envs[`TARGET_CC`] = join(
+          toolchainPath,
+          'bin',
+          `${crossTargetName}-gcc`,
+        )
+      }
+      if (!process.env.CXX && !process.env.TARGET_CXX) {
+        this.envs[`CXX`] = join(toolchainPath, 'bin', `${crossTargetName}-g++`)
+        this.envs[`TARGET_CXX`] = join(
+          toolchainPath,
+          'bin',
+          `${crossTargetName}-g++`,
+        )
+      }
+      if (
+        (process.env.CC?.startsWith('clang') &&
+          (process.env.TARGET_CC?.startsWith('clang') ||
+            !process.env.TARGET_CC)) ||
+        process.env.TARGET_CC?.startsWith('clang')
+      ) {
+        const CFLAGS = process.env.CFLAGS ?? ''
+        this.envs.CFLAGS = `--sysroot=${this.envs.TARGET_SYSROOT} --gcc-toolchain=${toolchainPath} ${CFLAGS}`
+      }
+      if (
+        (process.env.CXX?.startsWith('clang++') &&
+          (process.env.TARGET_CXX?.startsWith('clang++') ||
+            !process.env.TARGET_CXX)) ||
+        process.env.TARGET_CXX?.startsWith('clang++')
+      ) {
+        const CXXFLAGS = process.env.CXXFLAGS ?? ''
+        this.envs.CXXFLAGS = `--sysroot=${this.envs.TARGET_SYSROOT} --gcc-toolchain=${toolchainPath} ${CXXFLAGS} ${CXXFLAGS}`
+      }
+      this.envs.PATH = this.envs.PATH
+        ? `${toolchainPath}/bin:${this.envs.PATH}:${process.env.PATH}`
+        : `${toolchainPath}/bin:${process.env.PATH}`
+    } catch (e) {
+      debug.warn('Pick cross toolchain failed', e as Error)
+      // ignore, do nothing
+    }
+    return this
+  }
+
   private exec() {
     debug(`Start building crate: ${this.crate.name}`)
     debug('  %i', `cargo ${this.args.join(' ')}`)
@@ -156,15 +322,17 @@ class Builder {
 
     const watch = this.options.watch
     const buildTask = new Promise<void>((resolve, reject) => {
+      if (this.options.useCross && this.options.crossCompile) {
+        throw new Error(
+          '`--use-cross` and `--cross-compile` can not be used together',
+        )
+      }
       const command =
         process.env.CARGO ?? (this.options.useCross ? 'cross' : 'cargo')
       const buildProcess = spawn(command, this.args, {
-        env: {
-          ...process.env,
-          ...this.envs,
-        },
+        env: { ...process.env, ...this.envs },
         stdio: watch ? ['inherit', 'inherit', 'pipe'] : 'inherit',
-        cwd: this.cwd,
+        cwd: this.options.cwd,
         signal: controller.signal,
       })
 
@@ -178,18 +346,14 @@ class Builder {
       })
 
       buildProcess.once('error', (e) => {
-        reject(
-          new Error(`Build failed with error: ${e.message}`, {
-            cause: e,
-          }),
-        )
+        reject(new Error(`Build failed with error: ${e.message}`, { cause: e }))
       })
 
       // watch mode only, they are piped through stderr
       buildProcess.stderr?.on('data', (data) => {
         const output = data.toString()
         console.error(output)
-        if (/Finished\s(dev|release)/.test(output)) {
+        if (/Finished\s(`dev`|`release`)/.test(output)) {
           this.postBuild().catch(() => {})
         }
       })
@@ -313,13 +477,12 @@ class Builder {
   }
 
   private setEnvs() {
-    // type definition intermediate file
-    this.envs.TYPE_DEF_TMP_PATH = this.getIntermediateTypeFile()
-    // WASI register intermediate file
-    this.envs.WASI_REGISTER_TMP_PATH = this.getIntermediateWasiRegisterFile()
-    // TODO:
-    //   remove after napi-derive@v3 release
-    this.envs.CARGO_CFG_NAPI_RS_CLI_VERSION = CLI_VERSION
+    // TYPE DEF
+    if (this.enableTypeDef) {
+      this.envs.NAPI_TYPE_DEF_TMP_FOLDER =
+        this.generateIntermediateTypeDefFolder()
+      this.setForceBuildEnvs(this.envs.NAPI_TYPE_DEF_TMP_FOLDER)
+    }
 
     // RUSTFLAGS
     let rustflags =
@@ -352,7 +515,7 @@ class Builder {
     const linkerEnv = `CARGO_TARGET_${targetToEnvVar(
       this.target.triple,
     )}_LINKER`
-    if (linker && !process.env[linkerEnv]) {
+    if (linker && !process.env[linkerEnv] && !this.envs[linkerEnv]) {
       this.envs[linkerEnv] = linker
     }
 
@@ -378,10 +541,10 @@ class Builder {
       Object.assign(this.envs, {
         CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-android24-clang`,
         CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-androideabi24-clang`,
-        CC: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang`,
-        CXX: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang++`,
-        AR: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ar`,
-        RANLIB: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ranlib`,
+        TARGET_CC: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang`,
+        TARGET_CXX: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang++`,
+        TARGET_AR: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ar`,
+        TARGET_RANLIB: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ranlib`,
         ANDROID_NDK: ANDROID_NDK_LATEST_HOME,
         PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin:${process.env.PATH}`,
       })
@@ -396,6 +559,47 @@ class Builder {
         'wasm32-wasi-threads',
       )
       this.envs.EMNAPI_LINK_DIR = emnapi
+      this.envs.SETJMP_LINK_DIR = setjmpLib
+      const { WASI_SDK_PATH } = process.env
+
+      if (WASI_SDK_PATH && existsSync(WASI_SDK_PATH)) {
+        this.envs.CARGO_TARGET_WASM32_WASI_PREVIEW1_THREADS_LINKER = join(
+          WASI_SDK_PATH,
+          'bin',
+          'wasm-ld',
+        )
+        this.envs.CARGO_TARGET_WASM32_WASIP1_LINKER = join(
+          WASI_SDK_PATH,
+          'bin',
+          'wasm-ld',
+        )
+        this.envs.CARGO_TARGET_WASM32_WASIP1_THREADS_LINKER = join(
+          WASI_SDK_PATH,
+          'bin',
+          'wasm-ld',
+        )
+        this.envs.CARGO_TARGET_WASM32_WASIP2_LINKER = join(
+          WASI_SDK_PATH,
+          'bin',
+          'wasm-ld',
+        )
+        this.setEnvIfNotExists('CC', join(WASI_SDK_PATH, 'bin', 'clang'))
+        this.setEnvIfNotExists('CXX', join(WASI_SDK_PATH, 'bin', 'clang++'))
+        this.setEnvIfNotExists('AR', join(WASI_SDK_PATH, 'bin', 'ar'))
+        this.setEnvIfNotExists('RANLIB', join(WASI_SDK_PATH, 'bin', 'ranlib'))
+        this.setEnvIfNotExists(
+          'CFLAGS',
+          `--target=wasm32-wasi-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj -I${setjmpInclude}`,
+        )
+        this.setEnvIfNotExists(
+          'CXXFLAGS',
+          `--target=wasm32-wasi-threads --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj -I${setjmpInclude}`,
+        )
+        this.setEnvIfNotExists(
+          `LDFLAGS`,
+          `-fuse-ld=${WASI_SDK_PATH}/bin/wasm-ld --target=wasm32-wasi-threads`,
+        )
+      }
     }
 
     debug('Set envs: ')
@@ -406,13 +610,33 @@ class Builder {
     return this
   }
 
+  private setForceBuildEnvs(typeDefTmpFolder: string) {
+    // dynamically check all napi-rs deps and set `NAPI_FORCE_BUILD_{uppercase(snake_case(name))} = timestamp`
+    this.metadata.packages.forEach((crate) => {
+      if (
+        crate.dependencies.some((d) => d.name === 'napi-derive') &&
+        !existsSync(join(typeDefTmpFolder, crate.name))
+      ) {
+        this.envs[
+          `NAPI_FORCE_BUILD_${crate.name.replace(/-/g, '_').toUpperCase()}`
+        ] = Date.now().toString()
+      }
+    })
+  }
+
   private setFeatures() {
     const args = []
+    if (this.options.allFeatures && this.options.noDefaultFeatures) {
+      throw new Error(
+        'Cannot specify --all-features and --no-default-features together',
+      )
+    }
     if (this.options.allFeatures) {
       args.push('--all-features')
     } else if (this.options.noDefaultFeatures) {
       args.push('--no-default-features')
-    } else if (this.options.features) {
+    }
+    if (this.options.features) {
       args.push('--features', ...this.options.features)
     }
 
@@ -440,6 +664,10 @@ class Builder {
       this.args.push('--profile', this.options.profile)
     }
 
+    if (this.options.manifestPath) {
+      this.args.push('--manifest-path', this.options.manifestPath)
+    }
+
     if (this.options.cargoOptions?.length) {
       this.args.push(...this.options.cargoOptions)
     }
@@ -447,26 +675,25 @@ class Builder {
     return this
   }
 
-  private getIntermediateTypeFile() {
-    return join(
-      tmpdir(),
+  private generateIntermediateTypeDefFolder() {
+    let folder = join(
+      this.targetDir,
+      'napi-rs',
       `${this.crate.name}-${createHash('sha256')
         .update(this.crate.manifest_path)
         .update(CLI_VERSION)
         .digest('hex')
-        .substring(0, 8)}.napi_type_def.tmp`,
+        .substring(0, 8)}`,
     )
-  }
 
-  private getIntermediateWasiRegisterFile() {
-    return join(
-      tmpdir(),
-      `${this.crate.name}-${createHash('sha256')
-        .update(this.crate.manifest_path)
-        .update(CLI_VERSION)
-        .digest('hex')
-        .substring(0, 8)}.napi_wasi_register.tmp`,
-    )
+    if (!this.options.dtsCache) {
+      rmSync(folder, { recursive: true, force: true })
+      folder += `_${Date.now()}`
+    }
+
+    mkdirAsync(folder, { recursive: true })
+
+    return folder
   }
 
   private async postBuild() {
@@ -481,38 +708,21 @@ class Builder {
       })
     }
 
-    const dest = await this.copyArtifact()
+    const wasmBinaryName = await this.copyArtifact()
 
     // only for cdylib
     if (this.cdyLibName) {
       const idents = await this.generateTypeDef()
-      const intermediateWasiRegisterFile = this.envs.WASI_REGISTER_TMP_PATH
-      const wasiRegisterFunctions =
-        this.target.arch === 'wasm32'
-          ? JSON.parse(
-              await readFileAsync(intermediateWasiRegisterFile, 'utf8').catch(
-                (err) => {
-                  console.warn(
-                    `Read ${colors.yellowBright(
-                      intermediateWasiRegisterFile,
-                    )} failed, reason: ${err.message}`,
-                  )
-                  return `[]`
-                },
-              ),
-            )
-          : []
       const jsOutput = await this.writeJsBinding(idents)
-      const wasmOutput = await this.writeWasiBinding(
-        wasiRegisterFunctions,
-        dest ?? 'index.wasm',
+      const wasmBindingsOutput = await this.writeWasiBinding(
+        wasmBinaryName,
         idents,
       )
       if (jsOutput) {
         this.outputs.push(jsOutput)
       }
-      if (wasmOutput) {
-        this.outputs.push(wasmOutput)
+      if (wasmBindingsOutput) {
+        this.outputs.push(...wasmBindingsOutput)
       }
     }
 
@@ -520,7 +730,7 @@ class Builder {
   }
 
   private async copyArtifact() {
-    const [srcName, destName] = this.getArtifactNames()
+    const [srcName, destName, wasmBinaryName] = this.getArtifactNames()
     if (!srcName || !destName) {
       return
     }
@@ -530,6 +740,7 @@ class Builder {
     const src = join(this.targetDir, this.target.triple, profile, srcName)
     debug(`Copy artifact from: [${src}]`)
     const dest = join(this.outputDir, destName)
+    const isWasm = dest.endsWith('.wasm')
 
     try {
       if (await fileExists(dest)) {
@@ -538,22 +749,56 @@ class Builder {
       }
       debug('Copy artifact to:')
       debug('  %i', dest)
-      await copyFileAsync(src, dest)
+      if (isWasm) {
+        const { ModuleConfig } = await import('@napi-rs/wasm-tools')
+        debug('Generate debug wasm module')
+        try {
+          const debugWasmModule = new ModuleConfig()
+            .generateDwarf(true)
+            .generateNameSection(true)
+            .generateProducersSection(true)
+            .preserveCodeTransform(true)
+            .strictValidate(false)
+            .parse(await readFileAsync(src))
+          const debugWasmBinary = debugWasmModule.emitWasm(true)
+          await writeFileAsync(
+            dest.replace(/\.wasm$/, '.debug.wasm'),
+            debugWasmBinary,
+          )
+          debug('Generate release wasm module')
+          const releaseWasmModule = new ModuleConfig()
+            .generateDwarf(false)
+            .generateNameSection(false)
+            .generateProducersSection(false)
+            .preserveCodeTransform(false)
+            .strictValidate(false)
+            .onlyStableFeatures(false)
+            .parse(debugWasmBinary)
+          const releaseWasmBinary = releaseWasmModule.emitWasm(false)
+          await writeFileAsync(dest, releaseWasmBinary)
+        } catch (e) {
+          debug.warn(
+            `Failed to generate debug wasm module: ${(e as any).message ?? e}`,
+          )
+          await copyFileAsync(src, dest)
+        }
+      } else {
+        await copyFileAsync(src, dest)
+      }
       this.outputs.push({
-        kind: dest.endsWith('.node') ? 'node' : 'exe',
+        kind: dest.endsWith('.node') ? 'node' : isWasm ? 'wasm' : 'exe',
         path: dest,
       })
-      return dest
+      return wasmBinaryName ? join(this.outputDir, wasmBinaryName) : null
     } catch (e) {
-      throw new Error('Failed to copy artifact', {
-        cause: e,
-      })
+      throw new Error('Failed to copy artifact', { cause: e })
     }
   }
 
   private getArtifactNames() {
     if (this.cdyLibName) {
       const cdyLib = this.cdyLibName.replace(/-/g, '_')
+      const wasiTarget = this.config.targets.find((t) => t.platform === 'wasi')
 
       const srcName =
         this.target.platform === 'darwin'
@@ -572,12 +817,18 @@ class Builder {
         destName += `.${this.target.platformArchABI}`
       }
       if (srcName.endsWith('.wasm')) {
-        destName += '.wasi-wasm32.wasm'
+        destName += '.wasm'
       } else {
         destName += '.node'
       }
 
-      return [srcName, destName]
+      return [
+        srcName,
+        destName,
+        wasiTarget
+          ? `${this.config.binaryName}.${wasiTarget.platformArchABI}.wasm`
+          : null,
+      ]
     } else if (this.binName) {
       const srcName =
         this.target.platform === 'win32' ? `${this.binName}.exe` : this.binName
@@ -589,28 +840,78 @@ class Builder {
   }
 
   private async generateTypeDef() {
-    if (!(await fileExists(this.envs.TYPE_DEF_TMP_PATH))) {
+    const typeDefDir = this.envs.NAPI_TYPE_DEF_TMP_FOLDER
+    if (!this.enableTypeDef || !(await dirExistsAsync(typeDefDir))) {
       return []
     }
 
     const dest = join(this.outputDir, this.options.dts ?? 'index.d.ts')
 
-    const { dts, exports } = await processTypeDef(
-      this.envs.TYPE_DEF_TMP_PATH,
-      this.options.constEnum ?? true,
-      !this.options.noDtsHeader
-        ? this.options.dtsHeader ?? DEFAULT_TYPE_DEF_HEADER
-        : '',
-    )
+    let header = ''
+    let dts = ''
+    let exports: string[] = []
+
+    if (!this.options.noDtsHeader) {
+      const dtsHeader = this.options.dtsHeader ?? this.config.dtsHeader
+      // `dtsHeaderFile` in config > `dtsHeader` in cli flag > `dtsHeader` in config
+      if (this.config.dtsHeaderFile) {
+        try {
+          header = await readFileAsync(
+            join(this.options.cwd, this.config.dtsHeaderFile),
+            'utf-8',
+          )
+        } catch (e) {
+          debug.warn(
+            `Failed to read dts header file ${this.config.dtsHeaderFile}`,
+            e,
+          )
+        }
+      } else if (dtsHeader) {
+        header = dtsHeader
+      } else {
+        header = DEFAULT_TYPE_DEF_HEADER
+      }
+    }
+
+    const files = await readdirAsync(typeDefDir, { withFileTypes: true })
+
+    if (!files.length) {
+      debug('No type def files found. Skip generating dts file.')
+      return []
+    }
+
+    for (const file of files) {
+      if (!file.isFile()) {
+        continue
+      }
+
+      const { dts: fileDts, exports: fileExports } = await processTypeDef(
+        join(typeDefDir, file.name),
+        this.options.constEnum ?? this.config.constEnum ?? true,
+      )
+
+      dts += fileDts
+      exports.push(...fileExports)
+    }
+
+    if (dts.indexOf('ExternalObject<') > -1) {
+      header += `
+export declare class ExternalObject<T> {
+  readonly '': {
+    readonly '': unique symbol
+    [K: symbol]: T
+  }
+}
+`
+    }
+
+    dts = header + dts
 
     try {
       debug('Writing type def to:')
       debug('  %i', dest)
       await writeFileAsync(dest, dts, 'utf-8')
-      this.outputs.push({
-        kind: 'dts',
-        path: dest,
-      })
+      this.outputs.push({ kind: 'dts', path: dest })
     } catch (e) {
       debug.error('Failed to write type def file')
       debug.error(e as Error)
@@ -629,55 +930,103 @@ class Builder {
       return
     }
 
-    const name = parse(this.options.jsBinding ?? 'index.js').name
+    const name = this.options.jsBinding ?? 'index.js'
 
-    const cjs = createCjsBinding(
+    const createBinding = this.options.esm ? createEsmBinding : createCjsBinding
+    const binding = createBinding(
       this.config.binaryName,
       this.config.packageName,
       idents,
     )
 
     try {
-      const dest = join(this.outputDir, `${name}.js`)
+      const dest = join(this.outputDir, name)
       debug('Writing js binding to:')
       debug('  %i', dest)
-      await writeFileAsync(dest, cjs, 'utf-8')
-      return {
-        kind: 'js',
-        path: dest,
-      } satisfies Output
+      await writeFileAsync(dest, binding, 'utf-8')
+      return { kind: 'js', path: dest } satisfies Output
     } catch (e) {
       throw new Error('Failed to write js binding file', { cause: e })
     }
   }
 
   private async writeWasiBinding(
-    wasiRegisterFunctions: string[],
-    distFileName: string | undefined,
+    distFileName: string | undefined | null,
     idents: string[],
   ) {
-    if (distFileName && wasiRegisterFunctions.length) {
+    if (distFileName) {
       const { name, dir } = parse(distFileName)
-      const newPath = join(dir, `${this.config.binaryName}.wasi.mjs`)
+      const bindingPath = join(dir, `${this.config.binaryName}.wasi.cjs`)
+      const browserBindingPath = join(
+        dir,
+        `${this.config.binaryName}.wasi-browser.js`,
+      )
       const workerPath = join(dir, 'wasi-worker.mjs')
-      const declareCodes = `const { ${idents.join(', ')} } = binding\n`
-      const exportsCode = `export {\n${idents
-        .map((ident) => `  ${ident}`)
-        .join(',\n')}\n}`
+      const browserWorkerPath = join(dir, 'wasi-worker-browser.mjs')
+      const browserEntryPath = join(dir, 'browser.js')
+      const exportsCode =
+        `module.exports = __napiModule.exports\n` +
+        idents
+          .map(
+            (ident) =>
+              `module.exports.${ident} = __napiModule.exports.${ident}`,
+          )
+          .join('\n')
       await writeFileAsync(
-        newPath,
-        createWasiBinding(name, wasiRegisterFunctions) +
-          declareCodes +
+        bindingPath,
+        createWasiBinding(
+          name,
+          this.config.packageName,
+          this.config.wasm?.initialMemory,
+          this.config.wasm?.maximumMemory,
+        ) +
           exportsCode +
           '\n',
         'utf8',
       )
+      await writeFileAsync(
+        browserBindingPath,
+        createWasiBrowserBinding(
+          name,
+          this.config.wasm?.initialMemory,
+          this.config.wasm?.maximumMemory,
+          this.config.wasm?.browser?.fs,
+          this.config.wasm?.browser?.asyncInit,
+        ) +
+          `export default __napiModule.exports\n` +
+          idents
+            .map(
+              (ident) =>
+                `export const ${ident} = __napiModule.exports.${ident}`,
+            )
+            .join('\n') +
+          '\n',
+        'utf8',
+      )
       await writeFileAsync(workerPath, WASI_WORKER_TEMPLATE, 'utf8')
-      return {
-        kind: 'wasm',
-        path: newPath,
-      } satisfies Output
+      await writeFileAsync(
+        browserWorkerPath,
+        createWasiBrowserWorkerBinding(this.config.wasm?.browser?.fs ?? false),
+        'utf8',
+      )
+      await writeFileAsync(
+        browserEntryPath,
+        `export * from '${this.config.packageName}-wasm32-wasi'\n`,
+      )
+      return [
+        { kind: 'js', path: bindingPath },
+        { kind: 'js', path: browserBindingPath },
+        { kind: 'js', path: workerPath },
+        { kind: 'js', path: browserWorkerPath },
+        { kind: 'js', path: browserEntryPath },
+      ] satisfies Output[]
+    }
+    return []
+  }
+
+  private setEnvIfNotExists(env: string, value: string) {
+    if (!process.env[env]) {
+      this.envs[env] = value
     }
-    return null
   }
 }