@napi-rs/cli 3.0.0-alpha.8 → 3.0.0-alpha.81

package/src/api/build.ts

@@ -1,10 +1,19 @@
 import { spawn } from 'node:child_process'
 import { createHash } from 'node:crypto'
+import {
+  existsSync,
+  mkdirSync,
+  unlinkSync,
+  readFileSync,
+  writeFileSync,
+} from 'node:fs'
 import { createRequire } from 'node:module'
-import { tmpdir } from 'node:os'
+import { tmpdir, homedir } from 'node:os'
 import { parse, join, resolve } from 'node:path'
 
 import * as colors from 'colorette'
+import { groupBy, split } from 'lodash-es'
+import { include as setjmpInclude, lib as setjmpLib } from 'wasm-sjlj'
 
 import { BuildOptions as RawBuildOptions } from '../def/build.js'
 import {
@@ -30,9 +39,15 @@ import {
   writeFileAsync,
 } 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)
@@ -50,12 +65,17 @@ type BuildOptions = RawBuildOptions & {
 export async function buildProject(options: BuildOptions) {
   debug('napi build command receive options: %O', options)
 
+  options = {
+    dtsCache: true,
+    ...options,
+  }
+
   const cwd = options.cwd ?? process.cwd()
 
   const resolvePath = (...paths: string[]) => resolve(cwd, ...paths)
 
   const manifestPath = resolvePath(options.manifestPath ?? 'Cargo.toml')
-  const metadata = parseMetadata(manifestPath)
+  const metadata = await parseMetadata(manifestPath)
 
   const pkg = metadata.packages.find((p) => {
     // package with given name
@@ -72,6 +92,13 @@ export async function buildProject(options: BuildOptions) {
     )
   }
 
+  const depsNapiPackages = pkg.dependencies
+    .map((p) => metadata.packages.find((c) => c.name === p.name))
+    .filter(
+      (c): c is Crate =>
+        c != null && c.dependencies.some((d) => d.name == 'napi-derive'),
+    )
+
   const crateDir = parse(pkg.manifest_path).dir
 
   const builder = new Builder(
@@ -81,16 +108,20 @@ export async function buildProject(options: BuildOptions) {
     options.target
       ? parseTriple(options.target)
       : process.env.CARGO_BUILD_TARGET
-      ? parseTriple(process.env.CARGO_BUILD_TARGET)
-      : getSystemDefaultTarget(),
+        ? 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'),
+      resolvePath(
+        options.configPath ?? options.packageJsonPath ?? 'package.json',
+      ),
+      options.configPath ? resolvePath(options.configPath) : undefined,
     ),
+    depsNapiPackages,
   )
 
   return builder.build()
@@ -110,6 +141,7 @@ class Builder {
     private readonly outputDir: string,
     private readonly targetDir: string,
     private readonly config: NapiConfig,
+    private readonly depsNapiPackages: Crate[],
   ) {}
 
   get cdyLibName() {
@@ -143,11 +175,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,6 +315,11 @@ 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, {
@@ -189,7 +353,7 @@ class Builder {
       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(() => {})
         }
       })
@@ -315,11 +479,74 @@ 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
+    // Validate the packages and dependencies
+    if (existsSync(this.envs.TYPE_DEF_TMP_PATH)) {
+      const { depsNapiPackages, crate } = this
+      let shouldInvalidateSelf = false
+      const content = readFileSync(this.envs.TYPE_DEF_TMP_PATH, 'utf-8')
+      const typedefRaw = content
+        .split('\n')
+        .filter((line) => line.trim().length)
+        .map((line) => {
+          const [pkgName, ...jsonContents] = split(line, ':')
+          return {
+            pkgName,
+            jsonContent: jsonContents.join(':'),
+          }
+        })
+      const groupedTypedefRaw = groupBy(typedefRaw, ({ pkgName }) => pkgName)
+      const invalidPackages = new Set<string>()
+      for (const [pkgName, value] of Object.entries(groupedTypedefRaw)) {
+        const packageInvalidKey = `NAPI_PACKAGE_${pkgName.toUpperCase().replaceAll('-', '_')}_INVALID`
+        let done = false
+        for (const { jsonContent } of value) {
+          try {
+            // package_name: { "done": true } was written by napi-build in project build.rs
+            // if it exists, the package was successfully built and typedef was written
+            const json = JSON.parse(jsonContent)
+            if (json.done === true) {
+              done = true
+              break
+            }
+          } catch {
+            done = false
+            break
+          }
+        }
+        if (!done) {
+          process.env[packageInvalidKey] = `${Date.now()}`
+          shouldInvalidateSelf = true
+          invalidPackages.add(pkgName)
+        }
+      }
+      const typedefPackages = new Set(Object.keys(groupedTypedefRaw))
+      for (const crate of depsNapiPackages) {
+        if (!typedefPackages.has(crate.name)) {
+          debug('Set invalid package typedef: %i', crate.name)
+          shouldInvalidateSelf = true
+          process.env[
+            `NAPI_PACKAGE_${crate.name.toUpperCase().replaceAll('-', '_')}_INVALID`
+          ] = `${Date.now()}`
+        }
+      }
+      if (shouldInvalidateSelf) {
+        debug('Set invalid package typedef: %i', crate.name)
+        process.env[
+          `NAPI_PACKAGE_${crate.name.toUpperCase().replaceAll('-', '_')}_INVALID`
+        ] = `${Date.now()}`
+      }
+      // clean invalid packages typedef
+      if (invalidPackages.size) {
+        debug('Clean invalid packages typedef: %O', invalidPackages)
+        writeFileSync(
+          this.envs.TYPE_DEF_TMP_PATH,
+          typedefRaw
+            .filter(({ pkgName }) => !invalidPackages.has(pkgName))
+            .map(({ pkgName, jsonContent }) => `${pkgName}:${jsonContent}`)
+            .join('\n'),
+        )
+      }
+    }
 
     // RUSTFLAGS
     let rustflags =
@@ -352,7 +579,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
     }
 
@@ -373,15 +600,15 @@ class Builder {
         process.platform === 'darwin'
           ? 'darwin'
           : process.platform === 'win32'
-          ? 'windows'
-          : 'linux'
+            ? 'windows'
+            : 'linux'
       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 +623,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: ')
@@ -408,11 +676,17 @@ class Builder {
 
   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 +714,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)
     }
@@ -448,25 +726,21 @@ class Builder {
   }
 
   private getIntermediateTypeFile() {
-    return join(
-      tmpdir(),
-      `${this.crate.name}-${createHash('sha256')
-        .update(this.crate.manifest_path)
-        .update(CLI_VERSION)
-        .digest('hex')
-        .substring(0, 8)}.napi_type_def.tmp`,
-    )
-  }
-
-  private getIntermediateWasiRegisterFile() {
-    return join(
+    const dtsPath = join(
       tmpdir(),
       `${this.crate.name}-${createHash('sha256')
         .update(this.crate.manifest_path)
         .update(CLI_VERSION)
         .digest('hex')
-        .substring(0, 8)}.napi_wasi_register.tmp`,
+        .substring(0, 8)}.napi_type_def`,
     )
+    if (!this.options.dtsCache) {
+      try {
+        unlinkSync(dtsPath)
+      } catch {}
+      return `${dtsPath}_${Date.now()}.tmp`
+    }
+    return `${dtsPath}.tmp`
   }
 
   private async postBuild() {
@@ -481,38 +755,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 +777,7 @@ class Builder {
   }
 
   private async copyArtifact() {
-    const [srcName, destName] = this.getArtifactNames()
+    const [srcName, destName, wasmBinaryName] = this.getArtifactNames()
     if (!srcName || !destName) {
       return
     }
@@ -530,6 +787,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,12 +796,47 @@ 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,
@@ -554,15 +847,16 @@ class Builder {
   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'
           ? `lib${cdyLib}.dylib`
           : this.target.platform === 'win32'
-          ? `${cdyLib}.dll`
-          : this.target.platform === 'wasi' || this.target.platform === 'wasm'
-          ? `${cdyLib}.wasm`
-          : `lib${cdyLib}.so`
+            ? `${cdyLib}.dll`
+            : this.target.platform === 'wasi' || this.target.platform === 'wasm'
+              ? `${cdyLib}.wasm`
+              : `lib${cdyLib}.so`
 
       let destName = this.config.binaryName
       // add platform suffix to binary name
@@ -572,12 +866,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
@@ -597,8 +897,22 @@ class Builder {
 
     const { dts, exports } = await processTypeDef(
       this.envs.TYPE_DEF_TMP_PATH,
+      this.options.constEnum ?? this.config.constEnum ?? true,
       !this.options.noDtsHeader
-        ? this.options.dtsHeader ?? DEFAULT_TYPE_DEF_HEADER
+        ? (this.options.dtsHeader ??
+            (this.config.dtsHeaderFile
+              ? await readFileAsync(
+                  join(this.cwd, this.config.dtsHeaderFile),
+                  'utf-8',
+                ).catch(() => {
+                  debug.warn(
+                    `Failed to read dts header file ${this.config.dtsHeaderFile}`,
+                  )
+                  return null
+                })
+              : null) ??
+            this.config.dtsHeader ??
+            DEFAULT_TYPE_DEF_HEADER)
         : '',
     )
 
@@ -628,19 +942,20 @@ 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')
+      await writeFileAsync(dest, binding, 'utf-8')
       return {
         kind: 'js',
         path: dest,
@@ -651,32 +966,97 @@ class Builder {
   }
 
   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
   }
 }