@napi-rs/cli 3.8.6 → 3.9.1

package/src/utils/__tests__/target.spec.ts

@@ -1,13 +1,49 @@
+import { realpathSync } from 'node:fs'
+import { chmod, mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises'
 import os from 'os'
+import { join } from 'node:path'
 
 import test from 'ava'
 
 import {
+  wasiLibcHasNewFutexAbi,
   parseTriple,
   getSystemDefaultTarget,
+  rustBundledWasiLibc,
+  wasiSdkMajorVersion,
   AVAILABLE_TARGETS,
 } from '../target.js'
 
+async function withWasiSdkDir(
+  setup: (wasiSdkPath: string) => Promise<void>,
+  assertion: (wasiSdkPath: string) => void,
+) {
+  const wasiSdkPath = await mkdtemp(join(os.tmpdir(), 'napi-rs-wasi-sdk-'))
+  try {
+    await setup(wasiSdkPath)
+    assertion(wasiSdkPath)
+  } finally {
+    await rm(wasiSdkPath, { recursive: true, force: true })
+  }
+}
+
+async function writeVersionFile(wasiSdkPath: string, content: string) {
+  await writeFile(join(wasiSdkPath, 'VERSION'), content)
+}
+
+async function writeVersionHeader(wasiSdkPath: string, content: string) {
+  const headerDir = join(
+    wasiSdkPath,
+    'share',
+    'wasi-sysroot',
+    'include',
+    'wasm32-wasip1-threads',
+    'wasi',
+  )
+  await mkdir(headerDir, { recursive: true })
+  await writeFile(join(headerDir, 'version.h'), content)
+}
+
 test('should parse triple correctly', (t) => {
   t.snapshot(AVAILABLE_TARGETS.map(parseTriple))
 })
@@ -17,3 +53,188 @@ test('should get system default target correctly', (t) => {
 
   t.is(target.platform, os.platform())
 })
+
+test('should read the wasi-sdk major version from VERSION', async (t) => {
+  await withWasiSdkDir(
+    (wasiSdkPath) => writeVersionFile(wasiSdkPath, '34.0\n'),
+    (wasiSdkPath) => t.is(wasiSdkMajorVersion(wasiSdkPath), 34),
+  )
+})
+
+test('should ignore the build suffix in VERSION', async (t) => {
+  await withWasiSdkDir(
+    (wasiSdkPath) => writeVersionFile(wasiSdkPath, '33.0+m\n'),
+    (wasiSdkPath) => t.is(wasiSdkMajorVersion(wasiSdkPath), 33),
+  )
+})
+
+test('should read a pre wasi-sdk 30 VERSION', async (t) => {
+  await withWasiSdkDir(
+    (wasiSdkPath) => writeVersionFile(wasiSdkPath, '27.0\n'),
+    (wasiSdkPath) => t.is(wasiSdkMajorVersion(wasiSdkPath), 27),
+  )
+})
+
+test('should fall back to the wasi/version.h header', async (t) => {
+  await withWasiSdkDir(
+    (wasiSdkPath) =>
+      writeVersionHeader(
+        wasiSdkPath,
+        '#define __wasi_sdk_major__ 30\n#define __wasi_sdk_minor__ 0\n',
+      ),
+    (wasiSdkPath) => t.is(wasiSdkMajorVersion(wasiSdkPath), 30),
+  )
+})
+
+test('should prefer VERSION over the wasi/version.h header', async (t) => {
+  await withWasiSdkDir(
+    async (wasiSdkPath) => {
+      await writeVersionFile(wasiSdkPath, '34.0\n')
+      await writeVersionHeader(wasiSdkPath, '#define __wasi_sdk_major__ 33\n')
+    },
+    (wasiSdkPath) => t.is(wasiSdkMajorVersion(wasiSdkPath), 34),
+  )
+})
+
+test('should return null when no version signal exists', async (t) => {
+  await withWasiSdkDir(
+    () => Promise.resolve(),
+    (wasiSdkPath) => t.is(wasiSdkMajorVersion(wasiSdkPath), null),
+  )
+})
+
+test('should return null instead of throwing on a malformed VERSION', async (t) => {
+  await withWasiSdkDir(
+    (wasiSdkPath) => writeVersionFile(wasiSdkPath, 'not a version at all\n'),
+    (wasiSdkPath) => {
+      t.notThrows(() => wasiSdkMajorVersion(wasiSdkPath))
+      t.is(wasiSdkMajorVersion(wasiSdkPath), null)
+    },
+  )
+})
+
+test('should return null when the wasi-sdk path does not exist', (t) => {
+  t.is(wasiSdkMajorVersion(join(os.tmpdir(), 'napi-rs-missing-wasi-sdk')), null)
+})
+
+test('should detect the new futex ABI from a wasi-libc archive', async (t) => {
+  const dir = await mkdtemp(join(os.tmpdir(), 'napi-rs-wasi-libc-'))
+  try {
+    // wasi-libc moved the futex helpers into `futex.c` when it dropped the
+    // unused `int op` parameter. `__wait.c` survives either way, so only the
+    // presence of `futex.c` separates the two ABIs.
+    const newAbi = join(dir, 'libc-new.a')
+    const legacyAbi = join(dir, 'libc-legacy.a')
+    await writeFile(newAbi, '!<arch>\n__wait.c.obj\nfutex.c.obj\n')
+    await writeFile(
+      legacyAbi,
+      '!<arch>\n__wait.c.obj\n__wasilibc_busywait.c.obj\n',
+    )
+
+    t.true(wasiLibcHasNewFutexAbi(newAbi))
+    t.false(wasiLibcHasNewFutexAbi(legacyAbi))
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('should return null when the wasi-libc archive is unavailable', (t) => {
+  t.is(wasiLibcHasNewFutexAbi(null), null)
+  t.is(
+    wasiLibcHasNewFutexAbi(join(os.tmpdir(), 'napi-rs-missing-libc.a')),
+    null,
+  )
+})
+
+// A fake `rustc` must be an executable file, and `execFileSync` cannot run a
+// Windows `.cmd` shim without a shell. The behaviour under test does not
+// depend on the platform, so cover it on POSIX only.
+const posixOnly = process.platform === 'win32' ? test.serial.skip : test.serial
+
+/**
+ * Installs a `rustc` that reports its own working directory as the sysroot,
+ * so a test can tell which directory the probe ran in.
+ */
+async function withFakeRustc(
+  envVar: 'RUSTC' | 'CARGO_BUILD_RUSTC',
+  body: (dir: string) => Promise<void> | void,
+) {
+  const dir = await mkdtemp(join(os.tmpdir(), 'napi-rs-fake-rustc-'))
+  const rustc = join(dir, 'rustc')
+  // `$PWD` comes from the inherited environment, so ask the kernel for the
+  // real working directory. `-P` also resolves the `/var` symlink on macOS.
+  await writeFile(rustc, '#!/bin/sh\necho "$(pwd -P)/sysroot"\n')
+  await chmod(rustc, 0o755)
+  const previous = process.env[envVar]
+  process.env[envVar] = rustc
+  try {
+    await body(dir)
+  } finally {
+    if (previous === undefined) {
+      delete process.env[envVar]
+    } else {
+      process.env[envVar] = previous
+    }
+  }
+}
+
+posixOnly('probes the Rust sysroot from the build cwd', async (t) => {
+  await withFakeRustc('RUSTC', async (dir) => {
+    const caller = join(dir, 'caller')
+    const project = join(dir, 'project')
+    await mkdir(caller)
+    await mkdir(project)
+
+    // `rustc` is a rustup shim, so the directory it runs in picks the
+    // toolchain. Cargo is spawned with the build cwd; the probe must match it.
+    t.is(
+      rustBundledWasiLibc('wasm32-wasip1-threads', project),
+      join(
+        realpathSync(project),
+        'sysroot',
+        'lib',
+        'rustlib',
+        'wasm32-wasip1-threads',
+        'lib',
+        'self-contained',
+        'libc.a',
+      ),
+    )
+    t.not(
+      rustBundledWasiLibc('wasm32-wasip1-threads', caller),
+      rustBundledWasiLibc('wasm32-wasip1-threads', project),
+    )
+  })
+})
+
+posixOnly('falls back to CARGO_BUILD_RUSTC when RUSTC is unset', async (t) => {
+  const previousRustc = process.env.RUSTC
+  delete process.env.RUSTC
+  try {
+    await withFakeRustc('CARGO_BUILD_RUSTC', (dir) => {
+      t.true(
+        rustBundledWasiLibc('wasm32-wasip1-threads', dir)?.startsWith(
+          realpathSync(dir),
+        ),
+      )
+    })
+  } finally {
+    if (previousRustc !== undefined) {
+      process.env.RUSTC = previousRustc
+    }
+  }
+})
+
+posixOnly('returns null when the compiler cannot be run', (t) => {
+  const previous = process.env.RUSTC
+  process.env.RUSTC = join(os.tmpdir(), 'napi-rs-no-such-rustc')
+  try {
+    t.is(rustBundledWasiLibc('wasm32-wasip1-threads'), null)
+  } finally {
+    if (previous === undefined) {
+      delete process.env.RUSTC
+    } else {
+      process.env.RUSTC = previous
+    }
+  }
+})

package/src/utils/__tests__/typegen.spec.ts

@@ -1,3 +1,5 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
 import { join } from 'path'
 import { fileURLToPath } from 'url'
 
@@ -5,6 +7,24 @@ import test from 'ava'
 
 import { correctStringIdent, processTypeDef } from '../typegen.js'
 
+async function processInlineTypeDef(
+  lines: Array<Record<string, unknown>>,
+  constEnum = true,
+  runtimeStringEnum = false,
+) {
+  const dir = await mkdtemp(join(tmpdir(), 'napi-typegen-'))
+  const file = join(dir, 'defs')
+  await writeFile(
+    file,
+    lines.map((line) => JSON.stringify(line)).join('\n') + '\n',
+  )
+  try {
+    return await processTypeDef(file, constEnum, runtimeStringEnum)
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+}
+
 test('should ident string correctly', (t) => {
   const input = `
   /**
@@ -83,3 +103,98 @@ test('runtimeStringEnum is a no-op when constEnum is set', async (t) => {
 
   t.snapshot(dts)
 })
+
+test('simple type aliases stay on one line', async (t) => {
+  const { dts } = await processInlineTypeDef([
+    { kind: 'type', name: 'CustomU32', def: 'number' },
+  ])
+  t.true(dts.includes('export type CustomU32 = number'))
+  t.false(/export type CustomU32 =\s*\n/.test(dts))
+})
+
+test('empty classes do not contain a blank body', async (t) => {
+  const { dts } = await processInlineTypeDef([
+    { kind: 'struct', name: 'Blake2BKey', def: '' },
+  ])
+  t.true(dts.includes('export declare class Blake2BKey {}'))
+  t.false(dts.includes('class Blake2BKey {\n\n}'))
+})
+
+test('no-const-enum string enums emit a spaced union', async (t) => {
+  const { dts } = await processTypeDef(flagFixture, false, false)
+  t.true(dts.includes("export type Status = 'Active' | 'Inactive'"))
+  t.false(dts.includes("'Active'|"))
+})
+
+test('no-const-enum string enums keep commas inside variant docs', async (t) => {
+  const { dts } = await processInlineTypeDef(
+    [
+      {
+        kind: 'string_enum',
+        name: 'Status',
+        def: "/** First, documented variant */\n Active = 'Active',\n Inactive = 'Inactive'",
+      },
+    ],
+    false,
+    false,
+  )
+  t.true(dts.includes("export type Status = 'Active' | 'Inactive'"))
+  t.false(dts.includes('/** First |'))
+})
+
+test('no-const-enum string enums keep Unicode variant names', async (t) => {
+  const { dts } = await processInlineTypeDef(
+    [
+      {
+        kind: 'string_enum',
+        name: 'Status',
+        def: "成功 = '成功',\n Failed = 'Failed'",
+      },
+    ],
+    false,
+    false,
+  )
+  t.true(dts.includes("export type Status = '成功' | 'Failed'"))
+})
+
+test('no-const-enum string enums keep quoted JS property names', async (t) => {
+  const { dts } = await processInlineTypeDef(
+    [
+      {
+        kind: 'string_enum',
+        name: 'Header',
+        def: "'content-type' = 'content-type',\n Plain = 'plain'",
+      },
+    ],
+    false,
+    false,
+  )
+  t.true(dts.includes("export type Header = 'content-type' | 'plain'"))
+})
+
+test('no-const-enum string enums keep commas and escapes inside values', async (t) => {
+  const { dts } = await processInlineTypeDef(
+    [
+      {
+        kind: 'string_enum',
+        name: 'Label',
+        def: "Csv = 'a,b',\n Quoted = 'say \\'hi\\'',\n Count = 2",
+      },
+    ],
+    false,
+    false,
+  )
+  t.true(dts.includes("export type Label = 'a,b' | 'say \\'hi\\'' | 2"))
+})
+
+test('correctStringIdent keeps nested object-type fields indented', (t) => {
+  const input = `export declare function bufferComplexOverride(value: {
+  Buffer(): "line"
+mapped: { [Buffer in keyof T]: T[Buffer] }
+external: Buffer
+}): void`
+  const formatted = correctStringIdent(input, 0)
+  t.true(formatted.includes('  mapped: { [Buffer in keyof T]: T[Buffer] }'))
+  t.true(formatted.includes('  external: Buffer'))
+  t.false(formatted.includes('\nmapped:'))
+})

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export * from './log.js'
 export * from './misc.js'
+export * from './serialize.js'
 export * from './target.js'
 export * from './version.js'
 export * from './metadata.js'

package/src/utils/misc.ts

@@ -44,6 +44,7 @@ import { setTimeout as delay } from 'node:timers/promises'
 
 import pkgJson from '../../package.json' with { type: 'json' }
 import { debug } from './log.js'
+import { serializeJson } from './serialize.js'
 
 export const readFileAsync = readFile
 export const writeFileAsync = writeFile
@@ -132,7 +133,8 @@ interface ReconciliationReclaimState {
 }
 
 type ReconciliationMetadataOwner =
-  ReconciliationLockOwner | ReconciliationReclaimOwner
+  | ReconciliationLockOwner
+  | ReconciliationReclaimOwner
 
 interface ReconciliationCandidateState {
   owner: ReconciliationMetadataOwner
@@ -6153,10 +6155,7 @@ export async function updatePackageJson(
     return
   }
   const old = JSON.parse(await readFileAsync(path, 'utf8'))
-  await writeFileAsync(
-    path,
-    JSON.stringify(mergePackageJson(old, partial), null, 2),
-  )
+  await writeFileAsync(path, serializeJson(mergePackageJson(old, partial)))
 }
 
 export const CLI_VERSION = pkgJson.version

package/src/utils/serialize.ts

@@ -0,0 +1,47 @@
+import { stringify as stringifyToml } from '@std/toml'
+import { dump as yamlDump } from 'js-yaml'
+
+/**
+ * Canonical JSON for files the CLI writes (package.json, napi config).
+ *
+ * Always 2-space indent and a POSIX trailing newline. Callers must not
+ * add another `\n` or omit one — every JSON writer uses this helper.
+ */
+export function serializeJson(value: unknown): string {
+  return `${JSON.stringify(value, null, 2)}\n`
+}
+
+/**
+ * Canonical TOML for files the CLI rewrites (Cargo.toml).
+ *
+ * `@std/toml` stringify inserts a leading blank line and drops comments.
+ * We cannot preserve comments through parse→stringify. We only strip the
+ * leading blank and keep exactly one trailing newline — no regex rewrite
+ * of array contents, which would split commas inside quoted strings.
+ */
+export function serializeToml(value: Record<string, unknown>): string {
+  let serialized = stringifyToml(value)
+  if (serialized.startsWith('\n')) {
+    serialized = serialized.slice(1)
+  }
+  if (!serialized.endsWith('\n')) {
+    serialized += '\n'
+  }
+  return serialized
+}
+
+/**
+ * Canonical YAML for files the CLI rewrites (GitHub Actions workflows).
+ *
+ * Matches `napi new` / `napi rename` dump options and always ends with a
+ * trailing newline. Blank lines from the original document are not
+ * preserved — js-yaml dump cannot round-trip those.
+ */
+export function serializeYaml(value: unknown): string {
+  const serialized = yamlDump(value, {
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false,
+  })
+  return serialized.endsWith('\n') ? serialized : `${serialized}\n`
+}

package/src/utils/target.ts

@@ -1,4 +1,6 @@
-import { execSync } from 'node:child_process'
+import { execFileSync, execSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
 
 export type Platform = NodeJS.Platform | 'wasm' | 'wasi' | 'openharmony'
 
@@ -156,6 +158,153 @@ export function wasiTargetHasThreads(
   return getWasiTarget(target)?.flavor === 'threads'
 }
 
+function readTextFileOrNull(path: string): string | null {
+  try {
+    return readFileSync(path, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Detect the major version of a wasi-sdk installation.
+ *
+ * wasi-libc dropped the unused `int op` parameter from
+ * `__wasilibc_futex_wait_atomic_wait` and `__wasilibc_futex_wait_maybe_busy`,
+ * and wasi-sdk 34 is the first release that ships the 3-argument signature.
+ * Static archives compiled against the two signatures cannot be mixed, so the
+ * emnapi archives have to be picked by wasi-sdk version, not by target triple
+ * alone.
+ *
+ * `<wasiSdkPath>/VERSION` is the primary signal: every release ships it and
+ * its first line is the version (`27.0`, `33.0+m`, `34.0`, ...). The
+ * `wasi/version.h` header carrying `__wasi_sdk_major__` only appears from
+ * wasi-sdk 30 onwards, so it stays a fallback for trees without a `VERSION`.
+ *
+ * Returns `null` when neither signal is readable or parseable. Detection must
+ * never throw: an unknown wasi-sdk degrades to the legacy archives instead of
+ * failing the build.
+ */
+export function wasiSdkMajorVersion(wasiSdkPath: string): number | null {
+  const version = readTextFileOrNull(join(wasiSdkPath, 'VERSION'))
+  if (version) {
+    // `33.0+m` and friends carry a build suffix, so only the leading integer
+    // of the first line is meaningful.
+    const major = /^\s*(\d+)/.exec(version.split('\n', 1)[0])
+    if (major) {
+      return Number(major[1])
+    }
+  }
+  const versionHeader = readTextFileOrNull(
+    join(
+      wasiSdkPath,
+      'share',
+      'wasi-sysroot',
+      'include',
+      'wasm32-wasip1-threads',
+      'wasi',
+      'version.h',
+    ),
+  )
+  if (versionHeader) {
+    const major = /^\s*#\s*define\s+__wasi_sdk_major__\s+(\d+)/m.exec(
+      versionHeader,
+    )
+    if (major) {
+      return Number(major[1])
+    }
+  }
+  return null
+}
+
+/**
+ * Archive member that only exists in a wasi-libc carrying the 3-argument
+ * futex ABI.
+ *
+ * wasi-libc moved the wasi-threads futex helpers out of `__wait.c` and into a
+ * new `futex.c` in the same change that dropped the unused `int op` parameter
+ * (WebAssembly/wasi-libc#846). `__wait.c` still exists afterwards for other
+ * symbols, so the presence of `futex.c` — not the absence of `__wait.c` — is
+ * what separates the two ABIs.
+ */
+const NEW_FUTEX_ABI_ARCHIVE_MEMBER = 'futex.c.obj'
+
+/**
+ * Path to the wasi-libc that cargo links when no wasi-sdk is configured.
+ *
+ * Without `WASI_SDK_PATH` the target links through `rust-lld` against the
+ * wasi-libc bundled with the Rust standard library, so that copy — not a
+ * wasi-sdk — decides the futex ABI.
+ *
+ * `cwd` must be the directory Cargo is spawned in, because that is what
+ * selects the toolchain.
+ *
+ * Returns `null` when `rustc` cannot be queried or the target is not
+ * installed. Never throws: an undetectable sysroot degrades to the legacy
+ * archives.
+ */
+export function rustBundledWasiLibc(
+  wasiTarget: string,
+  cwd?: string,
+): string | null {
+  let sysroot: string
+  try {
+    // `rustc` is a rustup shim: it resolves `rust-toolchain.toml` and any
+    // directory override from its working directory. Cargo is spawned with
+    // the build cwd, so the probe must use the same one or it can read a
+    // different toolchain's wasi-libc than the one that gets linked.
+    // `RUSTC` and `CARGO_BUILD_RUSTC` bypass the shim entirely; Cargo gives
+    // `RUSTC` precedence, so do the same. `build.rustc` from the project's
+    // `.cargo/config.toml` stays out of reach without invoking cargo itself.
+    sysroot = execFileSync(
+      process.env.RUSTC ?? process.env.CARGO_BUILD_RUSTC ?? 'rustc',
+      ['--print', 'sysroot'],
+      {
+        cwd,
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'ignore'],
+      },
+    )
+      .toString('utf8')
+      .trim()
+  } catch {
+    return null
+  }
+  if (!sysroot) {
+    return null
+  }
+  return join(
+    sysroot,
+    'lib',
+    'rustlib',
+    wasiTarget,
+    'lib',
+    'self-contained',
+    'libc.a',
+  )
+}
+
+/**
+ * Whether a wasi-libc archive carries the 3-argument futex ABI.
+ *
+ * Returns `null` when the archive cannot be read, so callers can tell
+ * "definitely the legacy ABI" apart from "could not tell".
+ */
+export function wasiLibcHasNewFutexAbi(
+  libcArchivePath: string | null,
+): boolean | null {
+  if (!libcArchivePath) {
+    return null
+  }
+  let archive: Buffer
+  try {
+    archive = readFileSync(libcArchivePath)
+  } catch {
+    return null
+  }
+  return archive.includes(NEW_FUTEX_ABI_ARCHIVE_MEMBER, 0, 'latin1')
+}
+
 /**
  * A triple is a specific format for specifying a target architecture.
  * Triples may be referred to as a target triple which is the architecture for the artifact produced, and the host triple which is the architecture that the compiler is running on.