@napi-rs/cli 2.15.1 → 3.0.0-alpha.0

package/README.md

@@ -9,88 +9,27 @@
 
 > Cli tools for napi-rs
 
+```sh
+# or npm, pnpm
+yarn add @napi-rs/cli -D
+yarn napi build
+```
+
 ## Commands
 
+| Command         | desc                                                           | docs                                                |
+| --------------- | -------------------------------------------------------------- | --------------------------------------------------- |
+| new             | create new napi-rs project                                     | [./docs/new.md](./docs/new.md)                      |
+| build           | build napi-rs project                                          | [./docs/build.md](./docs/build.md)                  |
+| create-npm-dirs | Create npm package dirs for different platforms                | [./docs/create-npm-dirs](./docs/create-npm-dirs.md) |
+| artifacts       | Copy artifacts from Github Actions into specified dir          | [./docs/artifacts.md](./docs/artifacts.md)          |
+| rename          | Rename the napi-rs project                                     | [./docs/rename.md](./docs/rename.md)                |
+| universalize    | Combile built binaries into one universal binary               | [./docs/universalize.md](./docs/universalize.md)    |
+| version         | Update version in created npm packages by `create-npm-dirs`    | [./docs/version.md](./docs/version.md)              |
+| pre-publish     | Update package.json and copy addons into per platform packages | [./docs/pre-publish.md](./docs/pre-publish.md)      |
+
 ### Debug mode
 
 ```bash
 DEBUG="napi:*" napi [command]
 ```
-
-### `napi build`
-
-> Build command. Build rust codes and copy the dynamic lib binary file to the dist dir.
-
-#### `--platform`
-
-> default `false`
-
-Append `platform-arch-[abi]` name to dist file. eg: `index.darwin-x64.node`.
-
-#### `--release`
-
-> default `false`
-
-Is release build. This flag will be passed to `Cargo` directly.
-
-#### `--features`
-
-> default `''`
-
-Cargo features, passthrough to `cargo build` command.
-
-#### `--config,-c`
-
-> default `package.json`
-
-`napi-rs` config file name. `napi-rs` config example :
-
-```js
-{
-  "name": "@native-binding/fib",
-  "version": "0.1.0",
-  "napi": {
-    "name": "fib", // binary name
-    "triples": {
-      "defaults": true, // default true, if this value is true, will build `x86_64-pc-windows-msvc`, `x86_64-apple-darwin` and `x86_64-unknown-linux-gnu`
-      "additional": [
-        "x86_64-unknown-linux-musl",
-        "x86_64-unknown-freebsd",
-        "aarch64-unknown-linux-gnu"
-      ]
-    }
-  }
-}
-```
-
-#### `--cargo-name`
-
-> default `undefined`
-
-If not set, cli will read the `package.name` field in `Cargo.toml` under `process.cwd()`. The `-` in the name will be replaced with `_`.
-
-#### `--target`
-
-> default `undefined`
-
-> Note you should have `rustup` installed if omit the `--target` flag. The `@napi-rs/cli` will try to find the default target on your system via `rustup` if no `--target` specified.
-
-You can also define this value using the `RUST_TARGET` environment variable.
-
-This value will be passed to `Cargo build` command directly. eg: `napi build --target x86_64-unknown-linux-musl`
-
-#### `--cargo-flags`
-
-> default `undefined`
-
-Other flags you want pass to `Cargo build`.
-
-#### `--cargo-cwd`
-
-> default `undefined`
-
-This flag can be used to build binaries that are not in the current directory. The path that is passed to this flag should be relative to the current directory.
-
-### `napi artifacts`
-
-> Copy artifact files in Github actions.

package/cli.mjs

@@ -0,0 +1,12 @@
+import { execSync } from 'child_process'
+import { resolve } from 'path'
+import { fileURLToPath } from 'url'
+
+execSync(
+  `node --loader ts-node/esm/transpile-only ${resolve(fileURLToPath(import.meta.url), '../src/cli.ts')} ${process.argv
+    .slice(2)
+    .join(' ')}`,
+  {
+    stdio: 'inherit',
+  },
+)

package/dist/api/artifacts.d.ts

@@ -0,0 +1,2 @@
+import { ArtifactsOptions } from '../def/artifacts.js';
+export declare function collectArtifacts(userOptions: ArtifactsOptions): Promise<void>;

package/dist/api/artifacts.js

@@ -0,0 +1,50 @@
+import { join, parse, resolve } from 'path';
+import * as colors from 'colorette';
+import { applyDefaultArtifactsOptions, } from '../def/artifacts.js';
+import { readNapiConfig, debugFactory, readFileAsync, writeFileAsync, UniArchsByPlatform, readdirAsync, } from '../utils/index.js';
+const debug = debugFactory('artifacts');
+export async function collectArtifacts(userOptions) {
+    const options = applyDefaultArtifactsOptions(userOptions);
+    const packageJsonPath = resolve(options.cwd, options.packageJsonPath);
+    const { targets, binaryName } = await readNapiConfig(packageJsonPath);
+    const distDirs = targets.map((platform) => resolve(options.cwd, options.npmDir, platform.platformArchABI));
+    const universalSourceBins = new Set(targets
+        .filter((platform) => platform.arch === 'universal')
+        .flatMap((p) => UniArchsByPlatform[p.platform]?.map((a) => `${p.platform}-${a}`))
+        .filter(Boolean));
+    await collectNodeBinaries(resolve(options.cwd, options.outputDir)).then((output) => Promise.all(output.map(async (filePath) => {
+        debug.info(`Read [${colors.yellowBright(filePath)}]`);
+        const sourceContent = await readFileAsync(filePath);
+        const parsedName = parse(filePath);
+        const [_binaryName, platformArchABI] = parsedName.name.split('.');
+        if (_binaryName !== binaryName) {
+            debug.warn(`[${_binaryName}] is not matched with [${binaryName}], skip`);
+            return;
+        }
+        const dir = distDirs.find((dir) => dir.includes(platformArchABI));
+        if (!dir && universalSourceBins.has(platformArchABI)) {
+            debug.warn(`[${platformArchABI}] has no dist dir but it is source bin for universal arch, skip`);
+            return;
+        }
+        if (!dir) {
+            throw new Error(`No dist dir found for ${filePath}`);
+        }
+        const distFilePath = join(dir, parsedName.base);
+        debug.info(`Write file content to [${colors.yellowBright(distFilePath)}]`);
+        await writeFileAsync(distFilePath, sourceContent);
+        const distFilePathLocal = join(parse(packageJsonPath).dir, parsedName.base);
+        debug.info(`Write file content to [${colors.yellowBright(distFilePathLocal)}]`);
+        await writeFileAsync(distFilePathLocal, sourceContent);
+    })));
+}
+async function collectNodeBinaries(root) {
+    const files = await readdirAsync(root, { withFileTypes: true });
+    const nodeBinaries = files
+        .filter((file) => file.isFile() && file.name.endsWith('.node'))
+        .map((file) => join(root, file.name));
+    const dirs = files.filter((file) => file.isDirectory());
+    for (const dir of dirs) {
+        nodeBinaries.push(...(await collectNodeBinaries(join(root, dir.name))));
+    }
+    return nodeBinaries;
+}

package/dist/api/build.d.ts

@@ -0,0 +1,14 @@
+import { BuildOptions as RawBuildOptions } from '../def/build.js';
+type OutputKind = 'js' | 'dts' | 'node' | 'exe';
+type Output = {
+    kind: OutputKind;
+    path: string;
+};
+type BuildOptions = RawBuildOptions & {
+    cargoOptions?: string[];
+};
+export declare function buildProject(options: BuildOptions): Promise<{
+    task: Promise<Output[]>;
+    abort: () => void;
+}>;
+export {};

package/dist/api/build.js

@@ -0,0 +1,404 @@
+import { spawn } from 'child_process';
+import { createHash } from 'crypto';
+import { tmpdir } from 'os';
+import { parse, join, resolve } from 'path';
+import * as colors from 'colorette';
+import { CLI_VERSION, copyFileAsync, debugFactory, DEFAULT_TYPE_DEF_HEADER, fileExists, getSystemDefaultTarget, getTargetLinker, mkdirAsync, parseMetadata, parseTriple, processTypeDef, readNapiConfig, targetToEnvVar, tryInstallCargoBinary, unlinkAsync, writeFileAsync, } from '../utils/index.js';
+import { createJsBinding } from './templates/index.js';
+const debug = debugFactory('build');
+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);
+    const manifestPath = resolvePath(options.manifestPath ?? 'Cargo.toml');
+    const metadata = parseMetadata(manifestPath);
+    const pkg = metadata.packages.find((p) => {
+        // package with given name
+        if (options.package) {
+            return p.name === options.package;
+        }
+        else {
+            return p.manifest_path === manifestPath;
+        }
+    });
+    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 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')));
+    return builder.build();
+}
+class Builder {
+    options;
+    crate;
+    cwd;
+    target;
+    crateDir;
+    outputDir;
+    targetDir;
+    config;
+    args = [];
+    envs = {};
+    outputs = [];
+    constructor(options, crate, cwd, target, crateDir, outputDir, targetDir, config) {
+        this.options = options;
+        this.crate = crate;
+        this.cwd = cwd;
+        this.target = target;
+        this.crateDir = crateDir;
+        this.outputDir = outputDir;
+        this.targetDir = targetDir;
+        this.config = config;
+    }
+    get cdyLibName() {
+        return this.crate.targets.find((t) => t.crate_types.includes('cdylib'))
+            ?.name;
+    }
+    get binName() {
+        return (this.options.bin ??
+            // only available if not cdylib or bin name specified
+            (this.cdyLibName
+                ? null
+                : this.crate.targets.find((t) => t.crate_types.includes('bin'))?.name));
+    }
+    build() {
+        if (!this.cdyLibName) {
+            const warning = 'Missing `crate-type = ["cdylib"]` in [lib] config. The build result will not be available as node addon.';
+            if (this.binName) {
+                debug.warn(warning);
+            }
+            else {
+                throw new Error(warning);
+            }
+        }
+        return this.pickBinary()
+            .setPackage()
+            .setFeatures()
+            .setTarget()
+            .setEnvs()
+            .setBypassArgs()
+            .exec();
+    }
+    exec() {
+        debug(`Start building crate: ${this.crate.name}`);
+        debug('  %i', `cargo ${this.args.join(' ')}`);
+        const controller = new AbortController();
+        const buildTask = new Promise((resolve, reject) => {
+            const buildProcess = spawn('cargo', this.args, {
+                env: {
+                    ...process.env,
+                    ...this.envs,
+                },
+                stdio: 'inherit',
+                cwd: this.cwd,
+                signal: controller.signal,
+            });
+            buildProcess.once('exit', (code) => {
+                if (code === 0) {
+                    debug('%i', `Build crate ${this.crate.name} successfully!`);
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Build failed with exit code ${code}`));
+                }
+            });
+            buildProcess.once('error', (e) => {
+                reject(new Error(`Build failed with error: ${e.message}`, {
+                    cause: e,
+                }));
+            });
+        });
+        return {
+            task: buildTask.then(() => this.postBuild()),
+            abort: () => controller.abort(),
+        };
+    }
+    pickBinary() {
+        let set = false;
+        if (this.options.watch) {
+            if (process.env.CI) {
+                debug.warn('Watch mode is not supported in CI environment');
+            }
+            else {
+                debug('Use %i', 'cargo-watch');
+                tryInstallCargoBinary('cargo-watch', 'watch');
+                // yarn napi watch --target x86_64-unknown-linux-gnu [--cross-compile]
+                // ===>
+                // cargo watch [...] -- build --target x86_64-unknown-linux-gnu
+                // cargo watch [...] -- zigbuild --target x86_64-unknown-linux-gnu
+                this.args.push('watch', '--why', '-i', '*.{js,ts,node}', '-w', this.crateDir, '--', 'cargo');
+                set = true;
+            }
+        }
+        if (this.options.crossCompile) {
+            if (this.target.platform === 'win32') {
+                if (process.platform === 'win32') {
+                    debug.warn('You are trying to cross compile to win32 platform on win32 platform which is unnecessary.');
+                }
+                else {
+                    // use cargo-xwin to cross compile to win32 platform
+                    debug('Use %i', 'cargo-xwin');
+                    tryInstallCargoBinary('cargo-xwin', 'xwin');
+                    this.args.push('xwin', 'build');
+                    if (this.target.arch === 'ia32') {
+                        this.envs.XWIN_ARCH = 'x86';
+                    }
+                    set = true;
+                }
+            }
+            else {
+                if (this.target.platform === 'linux' &&
+                    process.platform === 'linux' &&
+                    this.target.arch === process.arch &&
+                    (function (abi) {
+                        const glibcVersionRuntime = 
+                        // @ts-expect-error
+                        process.report?.getReport()?.header?.glibcVersionRuntime;
+                        const libc = glibcVersionRuntime ? 'gnu' : 'musl';
+                        return abi === libc;
+                    })(this.target.abi)) {
+                    debug.warn('You are trying to cross compile to linux target on linux platform which is unnecessary.');
+                }
+                else if (this.target.platform === 'darwin' &&
+                    process.platform === 'darwin') {
+                    debug.warn('You are trying to cross compile to darwin target on darwin platform which is unnecessary.');
+                }
+                else {
+                    // use cargo-zigbuild to cross compile to other platforms
+                    debug('Use %i', 'cargo-zigbuild');
+                    tryInstallCargoBinary('cargo-zigbuild', 'zigbuild');
+                    this.args.push('zigbuild');
+                    set = true;
+                }
+            }
+        }
+        if (!set) {
+            this.args.push('build');
+        }
+        return this;
+    }
+    setPackage() {
+        const args = [];
+        if (this.options.package) {
+            args.push('--package', this.options.package);
+        }
+        if (this.binName) {
+            args.push('--bin', this.binName);
+        }
+        if (args.length) {
+            debug('Set package flags: ');
+            debug('  %O', args);
+            this.args.push(...args);
+        }
+        return this;
+    }
+    setTarget() {
+        debug('Set compiling target to: ');
+        debug('  %i', this.target.triple);
+        this.args.push('--target', this.target.triple);
+        return this;
+    }
+    setEnvs() {
+        // type definition intermediate file
+        this.envs.TYPE_DEF_TMP_PATH = this.getIntermediateTypeFile();
+        this.envs.CARGO_CFG_NAPI_RS_CLI_VERSION = CLI_VERSION;
+        // RUSTFLAGS
+        let rustflags = process.env.RUSTFLAGS ?? process.env.CARGO_BUILD_RUSTFLAGS ?? '';
+        if (this.target.abi?.includes('musl') &&
+            !rustflags.includes('target-feature=-crt-static')) {
+            rustflags += ' -C target-feature=-crt-static';
+        }
+        if (this.options.strip && !rustflags.includes('link-arg=-s')) {
+            rustflags += ' -C link-arg=-s';
+        }
+        if (rustflags.length) {
+            this.envs.RUSTFLAGS = rustflags;
+        }
+        // END RUSTFLAGS
+        // LINKER
+        const linker = getTargetLinker(this.target.triple);
+        if (linker &&
+            !process.env.RUSTC_LINKER &&
+            !process.env[`CARGET_TARGET_${targetToEnvVar(this.target.triple)}_LINKER`]) {
+            this.envs.RUSTC_LINKER = linker;
+        }
+        if (this.target.platform === 'android') {
+            const { ANDROID_NDK_LATEST_HOME } = process.env;
+            if (!ANDROID_NDK_LATEST_HOME) {
+                debug.warn(`${colors.red('ANDROID_NDK_LATEST_HOME')} environment variable is missing`);
+            }
+            const targetArch = this.target.arch === 'arm' ? 'armv7a' : 'aarch64';
+            const targetPlatform = this.target.arch === 'arm' ? 'androideabi24' : 'android24';
+            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`,
+                ANDROID_NDK: ANDROID_NDK_LATEST_HOME,
+                PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:${process.env.PATH}`,
+            });
+        }
+        // END LINKER
+        debug('Set envs: ');
+        Object.entries(this.envs).forEach(([k, v]) => {
+            debug('  %i', `${k}=${v}`);
+        });
+        return this;
+    }
+    setFeatures() {
+        const args = [];
+        if (this.options.allFeatures) {
+            args.push('--all-features');
+        }
+        else if (this.options.noDefaultFeatures) {
+            args.push('--no-default-features');
+        }
+        else if (this.options.features) {
+            args.push('--features', ...this.options.features);
+        }
+        debug('Set features flags: ');
+        debug('  %O', args);
+        this.args.push(...args);
+        return this;
+    }
+    setBypassArgs() {
+        if (this.options.release) {
+            this.args.push('--release');
+        }
+        if (this.options.verbose) {
+            this.args.push('--verbose');
+        }
+        if (this.options.targetDir) {
+            this.args.push('--target-dir', this.options.targetDir);
+        }
+        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`);
+    }
+    async postBuild() {
+        try {
+            debug(`Try to create output directory:`);
+            debug('  %i', this.outputDir);
+            await mkdirAsync(this.outputDir, { recursive: true });
+            debug(`Output directory created`);
+        }
+        catch (e) {
+            throw new Error(`Failed to create output directory ${this.outputDir}`, {
+                cause: e,
+            });
+        }
+        await this.copyArtifact();
+        // only for cdylib
+        if (this.cdyLibName) {
+            await this.generateTypeDef();
+            await this.writeJsBinding();
+        }
+        return this.outputs;
+    }
+    async copyArtifact() {
+        const [srcName, destName] = this.getArtifactNames();
+        if (!srcName || !destName) {
+            return;
+        }
+        const src = join(this.targetDir, this.target.triple, this.options.release ? 'release' : 'debug', srcName);
+        const dest = join(this.outputDir, destName);
+        try {
+            if (await fileExists(dest)) {
+                debug('Old artifact found, remove it first');
+                await unlinkAsync(dest);
+            }
+            debug('Copy artifact to:');
+            debug('  %i', dest);
+            await copyFileAsync(src, dest);
+            this.outputs.push({
+                kind: dest.endsWith('.node') ? 'node' : 'exe',
+                path: dest,
+            });
+        }
+        catch (e) {
+            throw new Error('Failed to copy artifact', {
+                cause: e,
+            });
+        }
+    }
+    getArtifactNames() {
+        if (this.cdyLibName) {
+            const cdyLib = this.cdyLibName.replace(/-/g, '_');
+            const srcName = this.target.platform === 'darwin'
+                ? `lib${cdyLib}.dylib`
+                : this.target.platform === 'win32'
+                    ? `${cdyLib}.dll`
+                    : `lib${cdyLib}.so`;
+            let destName = this.config.binaryName;
+            // add platform suffix to binary name
+            // index[.linux-x64-gnu].node
+            //       ^^^^^^^^^^^^^^
+            if (this.options.platform) {
+                destName += `.${this.target.platformArchABI}`;
+            }
+            destName += '.node';
+            return [srcName, destName];
+        }
+        else if (this.binName) {
+            const srcName = this.target.platform === 'win32' ? `${this.binName}.exe` : this.binName;
+            return [srcName, srcName];
+        }
+        return [];
+    }
+    async generateTypeDef() {
+        if (!(await fileExists(this.envs.TYPE_DEF_TMP_PATH))) {
+            return;
+        }
+        const dest = join(this.outputDir, this.options.dts ?? 'index.d.ts');
+        const dts = await processTypeDef(this.envs.TYPE_DEF_TMP_PATH, !this.options.noDtsHeader
+            ? this.options.dtsHeader ?? DEFAULT_TYPE_DEF_HEADER
+            : '');
+        try {
+            debug('Writing type def to:');
+            debug('  %i', dest);
+            await writeFileAsync(dest, dts, 'utf-8');
+            this.outputs.push({
+                kind: 'dts',
+                path: dest,
+            });
+        }
+        catch (e) {
+            debug.error('Failed to write type def file');
+            debug.error(e);
+        }
+    }
+    async writeJsBinding() {
+        if (!this.options.platform || this.options.noJsBinding) {
+            return;
+        }
+        const dest = join(this.outputDir, this.options.jsBinding ?? 'index.js');
+        const js = createJsBinding(this.config.binaryName, this.config.packageName);
+        try {
+            debug('Writing js binding to:');
+            debug('  %i', dest);
+            await writeFileAsync(dest, js, 'utf-8');
+            this.outputs.push({
+                kind: 'js',
+                path: dest,
+            });
+        }
+        catch (e) {
+            throw new Error('Failed to write js binding file', { cause: e });
+        }
+    }
+}

package/dist/api/create-npm-dirs.d.ts

@@ -0,0 +1,2 @@
+import { CreateNpmDirsOptions } from '../def/create-npm-dirs.js';
+export declare function createNpmDirs(userOptions: CreateNpmDirsOptions): Promise<void>;

package/dist/api/create-npm-dirs.js

@@ -0,0 +1,63 @@
+import { join, resolve } from 'path';
+import { applyDefaultCreateNpmDirsOptions, } from '../def/create-npm-dirs.js';
+import { debugFactory, readNapiConfig, mkdirAsync as rawMkdirAsync, pick, writeFileAsync as rawWriteFileAsync, } from '../utils/index.js';
+const debug = debugFactory('create-npm-dirs');
+export async function createNpmDirs(userOptions) {
+    const options = applyDefaultCreateNpmDirsOptions(userOptions);
+    async function mkdirAsync(dir) {
+        debug('Try to create dir: %i', dir);
+        if (options.dryRun) {
+            return;
+        }
+        await rawMkdirAsync(dir, {
+            recursive: true,
+        });
+    }
+    async function writeFileAsync(file, content) {
+        debug('Writing file %i', file);
+        if (options.dryRun) {
+            debug(content);
+            return;
+        }
+        await rawWriteFileAsync(file, content);
+    }
+    const packageJsonPath = resolve(options.cwd, options.packageJsonPath);
+    const npmPath = resolve(options.cwd, options.npmDir);
+    debug(`Read content from [${packageJsonPath}]`);
+    const { targets, binaryName, packageName, packageJson } = await readNapiConfig(packageJsonPath);
+    for (const target of targets) {
+        const targetDir = join(npmPath, `${target.platformArchABI}`);
+        await mkdirAsync(targetDir);
+        const binaryFileName = `${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],
+            ...pick(packageJson, 'description', 'keywords', 'author', 'authors', 'homepage', 'license', 'engines', 'publishConfig', 'repository', 'bugs'),
+        };
+        // Only works with yarn 3.1+
+        // https://github.com/yarnpkg/berry/pull/3981
+        if (target.abi === 'gnu') {
+            // @ts-expect-error
+            scopedPackageJson.libc = ['glibc'];
+        }
+        else if (target.abi === 'musl') {
+            // @ts-expect-error
+            scopedPackageJson.libc = ['musl'];
+        }
+        const targetPackageJson = join(targetDir, 'package.json');
+        await writeFileAsync(targetPackageJson, JSON.stringify(scopedPackageJson, null, 2));
+        const targetReadme = join(targetDir, 'README.md');
+        await writeFileAsync(targetReadme, readme(packageName, target));
+        debug.info(`${packageName}-${target.platformArchABI} created`);
+    }
+}
+function readme(packageName, target) {
+    return `# \`${packageName}-${target.platformArchABI}\`
+
+This is the **${target.triple}** binary for \`${packageName}\`
+`;
+}

package/dist/api/new.d.ts

@@ -0,0 +1,4 @@
+import { NewOptions as RawNewOptions } from '../def/new.js';
+type NewOptions = Required<RawNewOptions>;
+export declare function newProject(userOptions: RawNewOptions): Promise<void>;
+export { NewOptions };