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

package/dist/api/build.js

@@ -1,22 +1,28 @@
 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 { CLI_VERSION, copyFileAsync, debugFactory, DEFAULT_TYPE_DEF_HEADER, fileExists, getSystemDefaultTarget, getTargetLinker, mkdirAsync, parseMetadata, parseTriple, processTypeDef, readFileAsync, readNapiConfig, targetToEnvVar, tryInstallCargoBinary, unlinkAsync, 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 { include as setjmpInclude, lib as setjmpLib } from 'wasm-sjlj';
+import { CLI_VERSION, copyFileAsync, debugFactory, DEFAULT_TYPE_DEF_HEADER, fileExists, getSystemDefaultTarget, getTargetLinker, mkdirAsync, parseMetadata, parseTriple, processTypeDef, readFileAsync, readNapiConfig, targetToEnvVar, tryInstallCargoBinary, unlinkAsync, writeFileAsync, dirExistsAsync, readdirAsync, } from '../utils/index.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);
-export async function buildProject(options) {
-    debug('napi build command receive options: %O', options);
-    const cwd = options.cwd ?? process.cwd();
-    const resolvePath = (...paths) => resolve(cwd, ...paths);
+export async function buildProject(rawOptions) {
+    debug('napi build command receive options: %O', rawOptions);
+    const options = {
+        dtsCache: true,
+        ...rawOptions,
+        cwd: rawOptions.cwd ?? process.cwd(),
+    };
+    const resolvePath = (...paths) => resolve(options.cwd, ...paths);
     const manifestPath = resolvePath(options.manifestPath ?? 'Cargo.toml');
-    const metadata = parseMetadata(manifestPath);
-    const pkg = metadata.packages.find((p) => {
+    const metadata = await parseMetadata(manifestPath);
+    const crate = metadata.packages.find((p) => {
         // package with given name
         if (options.package) {
             return p.name === options.package;
@@ -25,40 +31,54 @@ export async function buildProject(options) {
             return p.manifest_path === manifestPath;
         }
     });
-    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();
 }
 class Builder {
-    options;
+    metadata;
     crate;
-    cwd;
-    target;
-    crateDir;
-    outputDir;
-    targetDir;
     config;
+    options;
     args = [];
     envs = {};
     outputs = [];
-    constructor(options, crate, cwd, target, crateDir, outputDir, targetDir, config) {
-        this.options = options;
+    target;
+    crateDir;
+    outputDir;
+    targetDir;
+    enableTypeDef = false;
+    constructor(metadata, crate, config, options) {
+        this.metadata = metadata;
         this.crate = crate;
-        this.cwd = cwd;
-        this.target = target;
-        this.crateDir = crateDir;
-        this.outputDir = outputDir;
-        this.targetDir = targetDir;
         this.config = config;
+        this.options = options;
+        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'))
@@ -85,24 +105,100 @@ class Builder {
             .setPackage()
             .setFeatures()
             .setTarget()
+            .pickCrossToolchain()
             .setEnvs()
             .setBypassArgs()
             .exec();
     }
+    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 = {
+                '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);
+            // ignore, do nothing
+        }
+        return this;
+    }
     exec() {
         debug(`Start building crate: ${this.crate.name}`);
         debug('  %i', `cargo ${this.args.join(' ')}`);
         const controller = new AbortController();
         const watch = this.options.watch;
         const buildTask = new Promise((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,
             });
             buildProcess.once('exit', (code) => {
@@ -115,15 +211,13 @@ 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(() => { });
                 }
             });
@@ -219,13 +313,12 @@ class Builder {
         return this;
     }
     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 = process.env.RUSTFLAGS ?? process.env.CARGO_BUILD_RUSTFLAGS ?? '';
         if (this.target.abi?.includes('musl') &&
@@ -248,7 +341,7 @@ class Builder {
         //   will detect by cargo config when it becomes stable
         //   see: https://github.com/rust-lang/cargo/issues/9301
         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;
         }
         if (this.target.platform === 'android') {
@@ -266,10 +359,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}`,
             });
@@ -278,6 +371,21 @@ class Builder {
         if (this.target.platform === 'wasi') {
             const emnapi = join(require.resolve('emnapi'), '..', 'lib', '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: ');
         Object.entries(this.envs).forEach(([k, v]) => {
@@ -285,15 +393,27 @@ class Builder {
         });
         return this;
     }
+    setForceBuildEnvs(typeDefTmpFolder) {
+        // 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();
+            }
+        });
+    }
     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);
         }
         debug('Set features flags: ');
@@ -314,24 +434,26 @@ class Builder {
         if (this.options.profile) {
             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);
         }
         return this;
     }
-    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`);
-    }
-    getIntermediateWasiRegisterFile() {
-        return join(tmpdir(), `${this.crate.name}-${createHash('sha256')
+    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_wasi_register.tmp`);
+            .substring(0, 8)}`);
+        if (!this.options.dtsCache) {
+            rmSync(folder, { recursive: true, force: true });
+            folder += `_${Date.now()}`;
+        }
+        mkdirAsync(folder, { recursive: true });
+        return folder;
     }
     async postBuild() {
         try {
@@ -345,30 +467,23 @@ class Builder {
                 cause: e,
             });
         }
-        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', idents);
+            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);
             }
         }
         return this.outputs;
     }
     async copyArtifact() {
-        const [srcName, destName] = this.getArtifactNames();
+        const [srcName, destName, wasmBinaryName] = this.getArtifactNames();
         if (!srcName || !destName) {
             return;
         }
@@ -376,6 +491,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)) {
                 debug('Old artifact found, remove it first');
@@ -383,22 +499,53 @@ 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.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 });
         }
     }
     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'
@@ -414,12 +561,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;
@@ -428,21 +581,61 @@ class Builder {
         return [];
     }
     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 = [];
+        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');
@@ -457,42 +650,58 @@ class Builder {
             idents.length === 0) {
             return;
         }
-        const name = parse(this.options.jsBinding ?? 'index.js').name;
-        const cjs = createCjsBinding(this.config.binaryName, this.config.packageName, idents);
+        const name = this.options.jsBinding ?? 'index.js';
+        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,
-            };
+            await writeFileAsync(dest, binding, 'utf-8');
+            return { kind: 'js', path: dest };
         }
         catch (e) {
             throw new Error('Failed to write js binding file', { cause: e });
         }
     }
-    async writeWasiBinding(wasiRegisterFunctions, distFileName, idents) {
-        if (distFileName && wasiRegisterFunctions.length) {
+    async writeWasiBinding(distFileName, idents) {
+        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}`;
-            await writeFileAsync(newPath, createWasiBinding(name, wasiRegisterFunctions) +
-                declareCodes +
+            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(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,
-            };
+            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 },
+            ];
+        }
+        return [];
+    }
+    setEnvIfNotExists(env, value) {
+        if (!process.env[env]) {
+            this.envs[env] = value;
         }
-        return null;
     }
 }
 //# sourceMappingURL=build.js.map