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

package/dist/api/build.js

@@ -1,21 +1,28 @@
 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 { 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 { 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);
+    options = {
+        dtsCache: true,
+        ...options,
+    };
     const cwd = options.cwd ?? process.cwd();
     const resolvePath = (...paths) => 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
         if (options.package) {
@@ -28,6 +35,9 @@ export async function buildProject(options) {
     if (!pkg) {
         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 depsNapiPackages = pkg.dependencies
+        .map((p) => metadata.packages.find((c) => c.name === p.name))
+        .filter((c) => c != null && c.dependencies.some((d) => d.name == 'napi-derive'));
     const crateDir = parse(pkg.manifest_path).dir;
     const builder = new Builder(options, pkg, cwd, options.target
         ? parseTriple(options.target)
@@ -35,7 +45,7 @@ export async function buildProject(options) {
             ? 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')));
+        metadata.target_directory, await readNapiConfig(resolvePath(options.configPath ?? options.packageJsonPath ?? 'package.json'), options.configPath ? resolvePath(options.configPath) : undefined), depsNapiPackages);
     return builder.build();
 }
 class Builder {
@@ -47,10 +57,11 @@ class Builder {
     outputDir;
     targetDir;
     config;
+    depsNapiPackages;
     args = [];
     envs = {};
     outputs = [];
-    constructor(options, crate, cwd, target, crateDir, outputDir, targetDir, config) {
+    constructor(options, crate, cwd, target, crateDir, outputDir, targetDir, config, depsNapiPackages) {
         this.options = options;
         this.crate = crate;
         this.cwd = cwd;
@@ -59,6 +70,7 @@ class Builder {
         this.outputDir = outputDir;
         this.targetDir = targetDir;
         this.config = config;
+        this.depsNapiPackages = depsNapiPackages;
     }
     get cdyLibName() {
         return this.crate.targets.find((t) => t.crate_types.includes('cdylib'))
@@ -85,16 +97,95 @@ 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: {
@@ -123,7 +214,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(() => { });
                 }
             });
@@ -221,11 +312,68 @@ class Builder {
     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();
+            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 = process.env.RUSTFLAGS ?? process.env.CARGO_BUILD_RUSTFLAGS ?? '';
         if (this.target.abi?.includes('musl') &&
@@ -248,7 +396,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 +414,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 +426,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]) => {
@@ -287,13 +450,16 @@ class Builder {
     }
     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 +480,28 @@ 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')
+        const dtsPath = 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')
-            .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`;
     }
     async postBuild() {
         try {
@@ -345,30 +515,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 +539,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,12 +547,44 @@ 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', {
@@ -399,6 +595,7 @@ class Builder {
     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 +611,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;
@@ -432,8 +635,16 @@ class Builder {
             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.noDtsHeader
-            ? this.options.dtsHeader ?? DEFAULT_TYPE_DEF_HEADER
+        const { dts, exports } = await processTypeDef(this.envs.TYPE_DEF_TMP_PATH, this.options.constEnum ?? this.config.constEnum ?? true, !this.options.noDtsHeader
+            ? (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)
             : '');
         try {
             debug('Writing type def to:');
@@ -457,13 +668,14 @@ 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');
+            await writeFileAsync(dest, binding, 'utf-8');
             return {
                 kind: 'js',
                 path: dest,
@@ -473,26 +685,59 @@ class Builder {
             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