@napi-rs/cli 3.0.0-alpha.4 → 3.0.0-alpha.41

package/src/api/build.ts

@@ -1,9 +1,12 @@
-import { spawn } from 'child_process'
-import { createHash } from 'crypto'
-import { tmpdir } from 'os'
-import { parse, join, resolve } from 'path'
+import { spawn } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { tmpdir, 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 {
@@ -20,6 +23,7 @@ import {
   parseMetadata,
   parseTriple,
   processTypeDef,
+  readFileAsync,
   readNapiConfig,
   Target,
   targetToEnvVar,
@@ -28,11 +32,20 @@ import {
   writeFileAsync,
 } from '../utils/index.js'
 
-import { createJsBinding } from './templates/index.js'
+import { createCjsBinding } from './templates/index.js'
+import {
+  createWasiBinding,
+  createWasiBrowserBinding,
+} from './templates/load-wasi-template.js'
+import {
+  WASI_WORKER_BROWSER_TEMPLATE,
+  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'
+type OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm'
 type Output = {
   kind: OutputKind
   path: string
@@ -76,15 +89,18 @@ 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,
     ),
   )
 
@@ -138,18 +154,147 @@ 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 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 linkerEnv = `CARGO_TARGET_${upperCaseTarget}_LINKER`
+      this.envs[linkerEnv] = join(
+        toolchainPath,
+        'bin',
+        `${this.target.triple}-gcc`,
+      )
+      if (!process.env.TARGET_SYSROOT) {
+        this.envs[`TARGET_SYSROOT`] = join(
+          toolchainPath,
+          this.target.triple,
+          'sysroot',
+        )
+      }
+      if (!process.env.TARGET_AR) {
+        this.envs[`TARGET_AR`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-ar`,
+        )
+      }
+      if (!process.env.TARGET_RANLIB) {
+        this.envs[`TARGET_RANLIB`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-ranlib`,
+        )
+      }
+      if (!process.env.TARGET_READELF) {
+        this.envs[`TARGET_READELF`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-readelf`,
+        )
+      }
+      if (!process.env.TARGET_C_INCLUDE_PATH) {
+        this.envs[`TARGET_C_INCLUDE_PATH`] = join(
+          toolchainPath,
+          this.target.triple,
+          'sysroot',
+          'usr',
+          'include/',
+        )
+      }
+      if (!process.env.CC && !process.env.TARGET_CC) {
+        this.envs[`CC`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-gcc`,
+        )
+        this.envs[`TARGET_CC`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-gcc`,
+        )
+      }
+      if (!process.env.CXX && !process.env.TARGET_CXX) {
+        this.envs[`CXX`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-g++`,
+        )
+        this.envs[`TARGET_CXX`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-g++`,
+        )
+      }
+      if (
+        (process.env.CC === 'clang' &&
+          (process.env.TARGET_CC === 'clang' || !process.env.TARGET_CC)) ||
+        process.env.TARGET_CC === 'clang'
+      ) {
+        this.envs.CFLAGS = `--sysroot=${this.envs.TARGET_SYSROOT}`
+      }
+      if (
+        (process.env.CXX === 'clang++' &&
+          (process.env.TARGET_CXX === 'clang++' || !process.env.TARGET_CXX)) ||
+        process.env.TARGET_CXX === 'clang++'
+      ) {
+        this.envs.CXXFLAGS = `--sysroot=${this.envs.TARGET_SYSROOT}`
+      }
+    } 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(' ')}`)
 
     const controller = new AbortController()
 
+    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, {
@@ -157,7 +302,7 @@ class Builder {
           ...process.env,
           ...this.envs,
         },
-        stdio: 'inherit',
+        stdio: watch ? ['inherit', 'inherit', 'pipe'] : 'inherit',
         cwd: this.cwd,
         signal: controller.signal,
       })
@@ -178,6 +323,15 @@ class Builder {
           }),
         )
       })
+
+      // 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)) {
+          this.postBuild().catch(() => {})
+        }
+      })
     })
 
     return {
@@ -207,6 +361,7 @@ class Builder {
           this.crateDir,
           '--',
           'cargo',
+          'build',
         )
         set = true
       }
@@ -353,18 +508,61 @@ class Builder {
       const targetArch = this.target.arch === 'arm' ? 'armv7a' : 'aarch64'
       const targetPlatform =
         this.target.arch === 'arm' ? 'androideabi24' : 'android24'
+      const hostPlatform =
+        process.platform === 'darwin'
+          ? 'darwin'
+          : process.platform === 'win32'
+            ? 'windows'
+            : 'linux'
       Object.assign(this.envs, {
-        CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-android24-clang`,
-        CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-androideabi24-clang`,
-        CC: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang`,
-        CXX: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang++`,
-        AR: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ar`,
+        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`,
         ANDROID_NDK: ANDROID_NDK_LATEST_HOME,
-        PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:${process.env.PATH}`,
+        PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin:${process.env.PATH}`,
       })
     }
     // END LINKER
 
+    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.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]) => {
       debug('  %i', `${k}=${v}`)
@@ -375,11 +573,17 @@ class Builder {
 
   private setFeatures() {
     const args = []
+    if (this.options.allFeatures && this.options.allFeatures) {
+      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)
     }
 
@@ -407,6 +611,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,12 +656,48 @@ class Builder {
       })
     }
 
-    await this.copyArtifact()
+    const dest = await this.copyArtifact()
 
     // only for cdylib
     if (this.cdyLibName) {
-      await this.generateTypeDef()
-      await this.writeJsBinding()
+      const idents = await this.generateTypeDef()
+      const intermediateWasiRegisterFile = this.envs.WASI_REGISTER_TMP_PATH
+      const wasiRegisterFunctions =
+        this.target.arch === 'wasm32'
+          ? await (async function readIntermediateWasiRegisterFile() {
+              const fileContent = await readFileAsync(
+                intermediateWasiRegisterFile,
+                'utf8',
+              ).catch((err) => {
+                console.warn(
+                  `Read ${colors.yellowBright(
+                    intermediateWasiRegisterFile,
+                  )} failed, reason: ${err.message}`,
+                )
+                return ``
+              })
+              return fileContent
+                .split('\n')
+                .map((l) => l.trim())
+                .filter((l) => l.length)
+                .map((line) => {
+                  const [_, fn] = line.split(':')
+                  return fn.trim()
+                })
+            })()
+          : []
+      const jsOutput = await this.writeJsBinding(idents)
+      const wasmBindingsOutput = await this.writeWasiBinding(
+        wasiRegisterFunctions,
+        dest ?? 'index.wasm',
+        idents,
+      )
+      if (jsOutput) {
+        this.outputs.push(jsOutput)
+      }
+      if (wasmBindingsOutput) {
+        this.outputs.push(...wasmBindingsOutput)
+      }
     }
 
     return this.outputs
@@ -483,6 +727,7 @@ class Builder {
         kind: dest.endsWith('.node') ? 'node' : 'exe',
         path: dest,
       })
+      return dest
     } catch (e) {
       throw new Error('Failed to copy artifact', {
         cause: e,
@@ -498,8 +743,10 @@ class Builder {
         this.target.platform === 'darwin'
           ? `lib${cdyLib}.dylib`
           : this.target.platform === 'win32'
-          ? `${cdyLib}.dll`
-          : `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
@@ -508,7 +755,11 @@ class Builder {
       if (this.options.platform) {
         destName += `.${this.target.platformArchABI}`
       }
-      destName += '.node'
+      if (srcName.endsWith('.wasm')) {
+        destName += '.wasm'
+      } else {
+        destName += '.node'
+      }
 
       return [srcName, destName]
     } else if (this.binName) {
@@ -523,13 +774,14 @@ class Builder {
 
   private async generateTypeDef() {
     if (!(await fileExists(this.envs.TYPE_DEF_TMP_PATH))) {
-      return
+      return []
     }
 
     const dest = join(this.outputDir, this.options.dts ?? 'index.d.ts')
 
-    const dts = await processTypeDef(
+    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
         : '',
@@ -547,27 +799,124 @@ class Builder {
       debug.error('Failed to write type def file')
       debug.error(e as Error)
     }
+
+    return exports
   }
 
-  private async writeJsBinding() {
-    if (!this.options.platform || this.options.noJsBinding) {
+  private async writeJsBinding(idents: string[]) {
+    if (
+      !this.options.platform ||
+      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      this.options.noJsBinding ||
+      idents.length === 0
+    ) {
       return
     }
 
-    const dest = join(this.outputDir, this.options.jsBinding ?? 'index.js')
+    const name = this.options.jsBinding ?? 'index.js'
 
-    const js = createJsBinding(this.config.binaryName, this.config.packageName)
+    const cjs = createCjsBinding(
+      this.config.binaryName,
+      this.config.packageName,
+      idents,
+    )
 
     try {
+      const dest = join(this.outputDir, name)
       debug('Writing js binding to:')
       debug('  %i', dest)
-      await writeFileAsync(dest, js, 'utf-8')
-      this.outputs.push({
+      await writeFileAsync(dest, cjs, '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,
+    idents: string[],
+  ) {
+    if (distFileName && wasiRegisterFunctions.length) {
+      const { name, dir } = parse(distFileName)
+      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 browserWorkerPath = join(dir, 'wasi-worker-browser.mjs')
+      const browserEntryPath = join(dir, 'browser.js')
+      const exportsCode = idents
+        .map(
+          (ident) => `module.exports.${ident} = __napiModule.exports.${ident}`,
+        )
+        .join('\n')
+      await writeFileAsync(
+        bindingPath,
+        createWasiBinding(
+          name,
+          this.config.packageName,
+          wasiRegisterFunctions,
+        ) +
+          exportsCode +
+          '\n',
+        'utf8',
+      )
+      await writeFileAsync(
+        browserBindingPath,
+        createWasiBrowserBinding(name, wasiRegisterFunctions) +
+          idents
+            .map(
+              (ident) =>
+                `export const ${ident} = __napiModule.exports.${ident}`,
+            )
+            .join('\n') +
+          '\n',
+        'utf8',
+      )
+      await writeFileAsync(workerPath, WASI_WORKER_TEMPLATE, 'utf8')
+      await writeFileAsync(
+        browserWorkerPath,
+        WASI_WORKER_BROWSER_TEMPLATE,
+        '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
+    }
+  }
 }

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

@@ -1,4 +1,6 @@
-import { join, resolve } from 'path'
+import { join, resolve } from 'node:path'
+
+import { parse } from 'semver'
 
 import {
   applyDefaultCreateNpmDirsOptions,
@@ -13,6 +15,8 @@ import {
   Target,
 } from '../utils/index.js'
 
+import type { PackageMeta } from './templates/package.json.js'
+
 const debug = debugFactory('create-npm-dirs')
 
 export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
@@ -43,20 +47,25 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
   const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
   const npmPath = resolve(options.cwd, options.npmDir)
 
-  debug(`Read content from [${packageJsonPath}]`)
+  debug(`Read content from [${options.configPath ?? packageJsonPath}]`)
 
   const { targets, binaryName, packageName, packageJson } =
-    await readNapiConfig(packageJsonPath)
+    await readNapiConfig(
+      packageJsonPath,
+      options.configPath ? resolve(options.cwd, options.configPath) : undefined,
+    )
 
   for (const target of targets) {
     const targetDir = join(npmPath, `${target.platformArchABI}`)
     await mkdirAsync(targetDir)
 
-    const binaryFileName = `${binaryName}.${target.platformArchABI}.node`
+    const binaryFileName =
+      target.arch === 'wasm32'
+        ? `${binaryName}.${target.platformArchABI}.wasm`
+        : `${binaryName}.${target.platformArchABI}.node`
     const scopedPackageJson = {
       name: `${packageName}-${target.platformArchABI}`,
       version: packageJson.version,
-      os: [target.platform],
       cpu: target.arch !== 'universal' ? [target.arch] : undefined,
       main: binaryFileName,
       files: [binaryFileName],
@@ -74,9 +83,48 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
         'bugs',
       ),
     }
+    if (target.arch !== 'wasm32') {
+      // @ts-expect-error
+      scopedPackageJson.os = [target.platform]
+    } else {
+      const entry = `${binaryName}.wasi.cjs`
+      scopedPackageJson.main = entry
+      // @ts-expect-error
+      scopedPackageJson.browser = `${binaryName}.wasi-browser.js`
+      scopedPackageJson.files.push(
+        entry,
+        // @ts-expect-error
+        scopedPackageJson.browser,
+        `wasi-worker.mjs`,
+        `wasi-worker-browser.mjs`,
+      )
+      let needRestrictNodeVersion = true
+      if (scopedPackageJson.engines?.node) {
+        try {
+          const { major } = parse(scopedPackageJson.engines.node) ?? {
+            major: 0,
+          }
+          if (major >= 14) {
+            needRestrictNodeVersion = false
+          }
+        } catch {
+          // ignore
+        }
+      }
+      if (needRestrictNodeVersion) {
+        scopedPackageJson.engines = {
+          node: '>=14.0.0',
+        }
+      }
+      const wasmRuntime = await fetch(
+        `https://registry.npmjs.org/@napi-rs/wasm-runtime`,
+      ).then((res) => res.json() as Promise<PackageMeta>)
+      // @ts-expect-error
+      scopedPackageJson.dependencies = {
+        '@napi-rs/wasm-runtime': `^${wasmRuntime['dist-tags'].latest}`,
+      }
+    }
 
-    // Only works with yarn 3.1+
-    // https://github.com/yarnpkg/berry/pull/3981
     if (target.abi === 'gnu') {
       // @ts-expect-error
       scopedPackageJson.libc = ['glibc']
@@ -93,7 +141,7 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
     const targetReadme = join(targetDir, 'README.md')
     await writeFileAsync(targetReadme, readme(packageName, target))
 
-    debug.info(`${packageName}-${target.platformArchABI} created`)
+    debug.info(`${packageName} -${target.platformArchABI} created`)
   }
 }