@neon-rs/cli 0.0.165 → 0.0.167

package/index.js

@@ -10245,7 +10245,7 @@ function wrappy (fn, cb) {
 
 /***/ }),
 
-/***/ 3236:
+/***/ 3235:
 /***/ ((__unused_webpack_module, __webpack_exports__, __nccwpck_require__) => {
 
 
@@ -10292,7 +10292,7 @@ function createInputStream(file) {
     return file ? (0,external_node_fs_namespaceObject.createReadStream)(file) : process.stdin;
 }
 class Dist {
-    static summary() { return 'Generate a .node file from a build.'; }
+    static summary() { return 'Generate a binary .node file from a cargo output log.'; }
     static syntax() { return 'neon dist [-n <name>] [-f <dylib>|[-l <log>] [-m <path>]] [-o <dist>]'; }
     static options() {
         return [
@@ -10314,6 +10314,7 @@ class Dist {
             { name: 'cross-rs', summary: '<https://github.com/cross-rs/cross>' }
         ];
     }
+    static extraSection() { }
     _log;
     _file;
     _mount;
@@ -11956,6 +11957,7 @@ class Bump {
             { name: 'npm version', summary: '<https://docs.npmjs.com/cli/commands/npm-version>' }
         ];
     }
+    static extraSection() { }
     _verbose;
     _dir;
     _workspaces;
@@ -12027,9 +12029,13 @@ var temp = __nccwpck_require__(591);
 const rust_namespaceObject = JSON.parse('{"aarch64-apple-darwin":"darwin-arm64","x86_64-apple-darwin":"darwin-x64","aarch64-apple-ios":"ios-arm64","x86_64-apple-ios":"ios-x64","aarch64-linux-android":"android-arm64","armv7-linux-androideabi":"android-arm-eabi","i686-linux-android":"android-ia32","x86_64-linux-android":"android-x64","aarch64-pc-windows-msvc":"win32-arm64-msvc","i686-pc-windows-gnu":"win32-ia32-gnu","i686-pc-windows-msvc":"win32-ia32-msvc","x86_64-pc-windows-gnu":"win32-x64-gnu","x86_64-pc-windows-msvc":"win32-x64-msvc","aarch64-unknown-linux-gnu":"linux-arm64-gnu","aarch64-unknown-linux-musl":"linux-arm64-musl","arm-unknown-linux-gnueabihf":"linux-arm-gnueabihf","arm-unknown-linux-musleabihf":"linux-arm-musleabihf","armv7-unknown-linux-gnueabihf":"linux-arm-gnueabihf","armv7-unknown-linux-musleabihf":"linux-arm-musleabihf","i686-unknown-linux-gnu":"linux-ia32-gnu","i686-unknown-linux-musl":"linux-ia32-musl","mips-unknown-linux-gnu":"linux-mips-gnu","mips-unknown-linux-musl":"linux-mips-musl","mips64-unknown-linux-gnuabi64":"linux-mips64-gnuabi64","mips64-unknown-linux-muslabi64":"linux-mips64-muslabi64","mips64el-unknown-linux-gnuabi64":"linux-mips64el-gnuabi64","mips64el-unknown-linux-muslabi64":"linux-mips64el-muslabi64","mipsel-unknown-linux-gnu":"linux-mipsel-gnu","mipsel-unknown-linux-musl":"linux-mipsel-musl","powerpc-unknown-linux-gnu":"linux-powerpc-gnu","powerpc64-unknown-linux-gnu":"linux-powerpc64-gnu","powerpc64le-unknown-linux-gnu":"linux-powerpc64le-gnu","riscv64gc-unknown-linux-gnu":"linux-riscv64gc-gnu","s390x-unknown-linux-gnu":"linux-s390x-gnu","sparc64-unknown-linux-gnu":"linux-sparc64-gnu","x86_64-unknown-linux-gnu":"linux-x64-gnu","x86_64-unknown-linux-gnux32":"linux-x64-gnux32","x86_64-unknown-linux-musl":"linux-x64-musl","i686-unknown-freebsd":"freebsd-ia32","x86_64-unknown-freebsd":"freebsd-x64"}');
 ;// CONCATENATED MODULE: ./data/node.json
 const node_namespaceObject = JSON.parse('{"darwin-arm64":{"platform":"darwin","arch":"arm64","abi":null,"llvm":["aarch64-apple-darwin"]},"darwin-x64":{"platform":"darwin","arch":"x64","abi":null,"llvm":["x86_64-apple-darwin"]},"ios-arm64":{"platform":"ios","arch":"arm64","abi":null,"llvm":["aarch64-apple-ios"]},"ios-x64":{"platform":"ios","arch":"x64","abi":null,"llvm":["x86_64-apple-ios"]},"android-arm64":{"platform":"android","arch":"arm64","abi":null,"llvm":["aarch64-linux-android"]},"android-arm-eabi":{"platform":"android","arch":"arm","abi":"eabi","llvm":["armv7-linux-androideabi"]},"android-ia32":{"platform":"android","arch":"ia32","abi":null,"llvm":["i686-linux-android"]},"android-x64":{"platform":"android","arch":"x64","abi":null,"llvm":["x86_64-linux-android"]},"win32-arm64-msvc":{"platform":"win32","arch":"arm64","abi":"msvc","llvm":["aarch64-pc-windows-msvc"]},"win32-ia32-gnu":{"platform":"win32","arch":"ia32","abi":"gnu","llvm":["i686-pc-windows-gnu"]},"win32-ia32-msvc":{"platform":"win32","arch":"ia32","abi":"msvc","llvm":["i686-pc-windows-msvc"]},"win32-x64-gnu":{"platform":"win32","arch":"x64","abi":"gnu","llvm":["x86_64-pc-windows-gnu"]},"win32-x64-msvc":{"platform":"win32","arch":"x64","abi":"msvc","llvm":["x86_64-pc-windows-msvc"]},"linux-arm64-gnu":{"platform":"linux","arch":"arm64","abi":"gnu","llvm":["aarch64-unknown-linux-gnu"]},"linux-arm64-musl":{"platform":"linux","arch":"arm64","abi":"musl","llvm":["aarch64-unknown-linux-musl"]},"linux-arm-gnueabihf":{"platform":"linux","arch":"arm","abi":"gnueabihf","llvm":["arm-unknown-linux-gnueabihf","armv7-unknown-linux-gnueabihf"]},"linux-arm-musleabihf":{"platform":"linux","arch":"arm","abi":"musleabihf","llvm":["arm-unknown-linux-musleabihf","armv7-unknown-linux-musleabihf"]},"linux-ia32-gnu":{"platform":"linux","arch":"ia32","abi":"gnu","llvm":["i686-unknown-linux-gnu"]},"linux-ia32-musl":{"platform":"linux","arch":"ia32","abi":"musl","llvm":["i686-unknown-linux-musl"]},"linux-mips-gnu":{"platform":"linux","arch":"mips","abi":"gnu","llvm":["mips-unknown-linux-gnu"]},"linux-mips-musl":{"platform":"linux","arch":"mips","abi":"musl","llvm":["mips-unknown-linux-musl"]},"linux-mips64-gnuabi64":{"platform":"linux","arch":"mips64","abi":"gnuabi64","llvm":["mips64-unknown-linux-gnuabi64"]},"linux-mips64-muslabi64":{"platform":"linux","arch":"mips64","abi":"muslabi64","llvm":["mips64-unknown-linux-muslabi64"]},"linux-mips64el-gnuabi64":{"platform":"linux","arch":"mips64el","abi":"gnuabi64","llvm":["mips64el-unknown-linux-gnuabi64"]},"linux-mips64el-muslabi64":{"platform":"linux","arch":"mips64el","abi":"muslabi64","llvm":["mips64el-unknown-linux-muslabi64"]},"linux-mipsel-gnu":{"platform":"linux","arch":"mipsel","abi":"gnu","llvm":["mipsel-unknown-linux-gnu"]},"linux-mipsel-musl":{"platform":"linux","arch":"mipsel","abi":"musl","llvm":["mipsel-unknown-linux-musl"]},"linux-powerpc-gnu":{"platform":"linux","arch":"powerpc","abi":"gnu","llvm":["powerpc-unknown-linux-gnu"]},"linux-powerpc64-gnu":{"platform":"linux","arch":"powerpc64","abi":"gnu","llvm":["powerpc64-unknown-linux-gnu"]},"linux-powerpc64le-gnu":{"platform":"linux","arch":"powerpc64le","abi":"gnu","llvm":["powerpc64le-unknown-linux-gnu"]},"linux-riscv64gc-gnu":{"platform":"linux","arch":"riscv64gc","abi":"gnu","llvm":["riscv64gc-unknown-linux-gnu"]},"linux-s390x-gnu":{"platform":"linux","arch":"s390x","abi":"gnu","llvm":["s390x-unknown-linux-gnu"]},"linux-sparc64-gnu":{"platform":"linux","arch":"sparc64","abi":"gnu","llvm":["sparc64-unknown-linux-gnu"]},"linux-x64-gnu":{"platform":"linux","arch":"x64","abi":"gnu","llvm":["x86_64-unknown-linux-gnu"]},"linux-x64-gnux32":{"platform":"linux","arch":"x64","abi":"gnux32","llvm":["x86_64-unknown-linux-gnux32"]},"linux-x64-musl":{"platform":"linux","arch":"x64","abi":"musl","llvm":["x86_64-unknown-linux-musl"]},"freebsd-ia32":{"platform":"freebsd","arch":"ia32","abi":null,"llvm":["i686-unknown-freebsd"]},"freebsd-x64":{"platform":"freebsd","arch":"x64","abi":null,"llvm":["x86_64-unknown-freebsd"]}}');
+;// CONCATENATED MODULE: ./data/family.json
+const family_namespaceObject = JSON.parse('{"windows":{"win32-x64-msvc":"x86_64-pc-windows-msvc"},"macos":{"darwin-x64":"x86_64-apple-darwin","darwin-arm64":"aarch64-apple-darwin"},"linux":{"linux-x64-gnu":"x86_64-unknown-linux-gnu","linux-arm-gnueabihf":"armv7-unknown-linux-gnueabihf"},"desktop":{"win32-x64-msvc":"x86_64-pc-windows-msvc","darwin-x64":"x86_64-apple-darwin","darwin-arm64":"aarch64-apple-darwin","linux-x64-gnu":"x86_64-unknown-linux-gnu"},"mobile":{"win32-arm64-msvc":"aarch64-pc-windows-msvc","linux-arm-gnueabihf":"armv7-unknown-linux-gnueabihf","android-arm-eabi":"armv7-linux-androideabi"},"common":["desktop"],"extended":["desktop","mobile"]}');
 ;// CONCATENATED MODULE: ./src/target.ts
 
 
+
+
 function isRustTarget(x) {
     return (typeof x === 'string') && (x in rust_namespaceObject);
 }
@@ -12046,6 +12052,31 @@ function assertIsNodeTarget(x) {
         throw new RangeError(`invalid Node target: ${x}`);
     }
 }
+function isTargetFamilyKey(x) {
+    return (typeof x === 'string') && (x in family_namespaceObject);
+}
+function assertIsTargetFamilyKey(x) {
+    if (!isTargetFamilyKey(x)) {
+        throw new RangeError(`invalid target family name: ${x}`);
+    }
+}
+function lookupTargetFamily(key) {
+    return family_namespaceObject[key];
+}
+function merge(maps) {
+    const merged = Object.create(null);
+    for (const map of maps) {
+        Object.assign(merged, map);
+    }
+    return merged;
+}
+function expandTargetFamily(family) {
+    return isTargetFamilyKey(family)
+        ? expandTargetFamily(lookupTargetFamily(family))
+        : Array.isArray(family)
+            ? merge(family.map(expandTargetFamily))
+            : family;
+}
 function getTargetDescriptor(target) {
     const node = rust_namespaceObject[target];
     if (!isNodeTarget(node)) {
@@ -12064,11 +12095,39 @@ function getTargetDescriptor(target) {
         llvm: nodeDescriptor.llvm
     };
 }
+function node2Rust(target) {
+    return node_namespaceObject[target].llvm.map(rt => {
+        assertIsRustTarget(rt);
+        return rt;
+    });
+}
+function rust2Node(target) {
+    const nt = rust_namespaceObject[target];
+    assertIsNodeTarget(nt);
+    return nt;
+}
+async function getCurrentTarget(log) {
+    log(`rustc -vV`);
+    const result = await execa("rustc", ["-vV"], { shell: true });
+    if (result.exitCode !== 0) {
+        throw new Error(`Could not determine current Rust target: ${result.stderr}`);
+    }
+    const hostLine = result.stdout.split(/\n/).find(line => line.startsWith('host:'));
+    log(`found host line: ${hostLine}`);
+    if (!hostLine) {
+        throw new Error("Could not determine current Rust target (unexpected rustc output)");
+    }
+    const target = hostLine.replace(/^host:\s+/, '');
+    log(`currentTarget result: "${target}"`);
+    assertIsRustTarget(target);
+    return target;
+}
 
 ;// CONCATENATED MODULE: ./src/manifest.ts
 
 
 
+
 function assertIsObject(json, path) {
     if (!json || typeof json !== 'object') {
         throw new TypeError(`expected "${path}" property to be an object, found ${json}`);
@@ -12355,6 +12414,71 @@ class SourceManifest extends AbstractManifest {
         }
         return new BinaryManifest(json);
     }
+    async addTargetPair(pair) {
+        const { node, rust } = pair;
+        const targets = this.cfg().targets;
+        if (targets[node] === rust) {
+            return null;
+        }
+        targets[node] = rust;
+        await this.save();
+        return pair;
+    }
+    async addNodeTarget(target) {
+        const rt = node2Rust(target);
+        if (rt.length > 1) {
+            throw new Error(`multiple Rust targets found for Node target ${target}; please specify one of ${rt.join(', ')}`);
+        }
+        return await this.addTargetPair({ node: target, rust: rt[0] });
+    }
+    async addRustTarget(target) {
+        return await this.addTargetPair({ node: rust2Node(target), rust: target });
+    }
+    async addTargets(family) {
+        const targets = this.cfg().targets;
+        let modified = [];
+        for (const [key, value] of Object.entries(family)) {
+            const node = key;
+            const rust = value;
+            if (targets[node] === rust) {
+                continue;
+            }
+            targets[node] = rust;
+            modified.push({ node, rust });
+        }
+        if (modified.length) {
+            await this.save();
+        }
+        return modified;
+    }
+    async updateTargets(log, bundle) {
+        const packages = this.packageNames();
+        const specs = packages.map(name => `${name}@${this.version}`);
+        log(`npm install --save-exact -O ${specs.join(' ')}`);
+        const result = await execa('npm', ['install', '--save-exact', '-O', ...specs], { shell: true });
+        if (result.exitCode !== 0) {
+            log(`npm failed with exit code ${result.exitCode}`);
+            console.error(result.stderr);
+            process.exit(result.exitCode);
+        }
+        log(`package.json after: ${await promises_namespaceObject.readFile(external_node_path_namespaceObject.join(process.cwd(), "package.json"))}`);
+        if (!bundle) {
+            return;
+        }
+        const PREAMBLE = `// AUTOMATICALLY GENERATED FILE. DO NOT EDIT.
+//
+// This code is never executed but is detected by the static analysis of
+// bundlers such as \`@vercel/ncc\`. The require() expression that selects
+// the right binary module for the current platform is too dynamic to be
+// analyzable by bundler analyses, so this module provides an exhaustive
+// static list for those analyses.
+
+if (0) {
+`;
+        const requires = packages.map(name => `  require('${name}');`).join('\n');
+        log(`generating bundler compatibility module at ${bundle}`);
+        await promises_namespaceObject.writeFile(bundle, PREAMBLE + requires + '\n}\n');
+    }
 }
 function upgradeSourceV1(object) {
     function splitSwap([key, value]) {
@@ -12392,7 +12516,7 @@ function upgradeBinaryV1(json) {
     };
 }
 
-;// CONCATENATED MODULE: ./src/commands/pack-build.ts
+;// CONCATENATED MODULE: ./src/commands/tarball.ts
 
 
 
@@ -12401,16 +12525,16 @@ function upgradeBinaryV1(json) {
 
 
 const mktemp = temp.track().mkdir;
-const pack_build_OPTIONS = [
+const tarball_OPTIONS = [
     { name: 'file', alias: 'f', type: String, defaultValue: 'index.node' },
     { name: 'target', alias: 't', type: String, defaultValue: null },
     { name: 'in-dir', alias: 'i', type: String, defaultValue: null },
     { name: 'out-dir', alias: 'o', type: String, defaultValue: null },
     { name: 'verbose', alias: 'v', type: Boolean, defaultValue: false },
 ];
-class PackBuild {
-    static summary() { return 'Create an npm tarball from a prebuild.'; }
-    static syntax() { return 'neon pack-build [-f <addon>] [-t <target>] [-i <dir>] [-o <dir>] [-v]'; }
+class Tarball {
+    static summary() { return 'Create an npm tarball from a binary .node file.'; }
+    static syntax() { return 'neon tarball [-f <addon>] [-t <target>] [-i <dir>] [-o <dir>] [-v]'; }
     static options() {
         return [
             { name: '-f, --file <addon>', summary: 'Prebuilt .node file to pack. (Default: index.node)' },
@@ -12427,13 +12551,14 @@ class PackBuild {
             { name: 'cross-rs', summary: '<https://github.com/cross-rs/cross>' }
         ];
     }
+    static extraSection() { }
     _target;
     _addon;
     _inDir;
     _outDir;
     _verbose;
     constructor(argv) {
-        const options = dist_default()(pack_build_OPTIONS, { argv });
+        const options = dist_default()(tarball_OPTIONS, { argv });
         this._target = options.target || null;
         this._addon = options.file;
         this._inDir = options['in-dir'] || null;
@@ -12442,26 +12567,11 @@ class PackBuild {
     }
     log(msg) {
         if (this._verbose) {
-            console.error("[neon pack-build] " + msg);
+            console.error("[neon tarball] " + msg);
         }
     }
-    async currentTarget() {
-        this.log(`rustc -vV`);
-        const result = await execa("rustc", ["-vV"], { shell: true });
-        if (result.exitCode !== 0) {
-            throw new Error(`Could not determine current Rust target: ${result.stderr}`);
-        }
-        const hostLine = result.stdout.split(/\n/).find(line => line.startsWith('host:'));
-        this.log(`found host line: ${hostLine}`);
-        if (!hostLine) {
-            throw new Error("Could not determine current Rust target (unexpected rustc output)");
-        }
-        const target = hostLine.replace(/^host:\s+/, '');
-        this.log(`currentTarget result: "${target}"`);
-        return target;
-    }
     async createTempDir(sourceManifest) {
-        const target = this._target || await this.currentTarget();
+        const target = this._target || await getCurrentTarget(msg => this.log(msg));
         if (!isRustTarget(target)) {
             throw new Error(`Rust target ${target} not supported.`);
         }
@@ -12533,19 +12643,159 @@ class PackBuild {
     ;
 }
 
-;// CONCATENATED MODULE: ./src/commands/install-builds.ts
+;// CONCATENATED MODULE: ./src/commands/add-target.ts
 
 
 
 
 
-const install_builds_OPTIONS = [
+function optionArray(option) {
+    return option == null ? [] : [option];
+}
+const add_target_OPTIONS = [
     { name: 'bundle', alias: 'b', type: String, defaultValue: null },
+    { name: 'platform', alias: 'p', type: String, defaultValue: null },
+    { name: 'arch', alias: 'a', type: String, defaultValue: null },
+    { name: 'abi', type: String, defaultValue: null },
+    { name: 'out-dir', alias: 'o', type: String, defaultValue: 'npm' },
     { name: 'verbose', alias: 'v', type: Boolean, defaultValue: false }
 ];
-class InstallBuilds {
-    static summary() { return 'Install dependencies on prebuilds in package.json.'; }
-    static syntax() { return 'neon install-builds [-b <file>]'; }
+class AddTarget {
+    static summary() { return 'Add a new build target to package.json.'; }
+    static syntax() { return 'neon add-target [<t> | -p <p> -a <arch> [--abi <abi>]] [-o <d>] [-b <f>]'; }
+    static options() {
+        return [
+            { name: '<t>', summary: 'Full target name, in either Node or Rust convention.' },
+            {
+                name: '',
+                summary: 'This may be a target name in either Node or Rust convention, or one of the Neon target family presets described below. (Default: current target)'
+            },
+            { name: '-p, --platform <p>', summary: 'Target platform name. (Default: current platform)' },
+            { name: '-a, --arch <arch>', summary: 'Target architecture name. (Default: current arch)' },
+            { name: '--abi <abi>', summary: 'Target ABI name. (Default: current ABI)' },
+            { name: '-o, --out-dir <d>', summary: 'Output directory for target template tree. (Default: npm)' },
+            { name: '-b, --bundle <f>', summary: 'File to generate bundling metadata.' },
+            {
+                name: '',
+                summary: 'This generated file ensures support for bundlers (e.g. @vercel/ncc), which rely on static analysis to detect and enable any addons used by the library.'
+            },
+            { name: '-v, --verbose', summary: 'Enable verbose logging. (Default: false)' }
+        ];
+    }
+    static seeAlso() { }
+    static extraSection() {
+        return {
+            title: 'Target Family Presets',
+            details: [
+                { name: 'linux', summary: 'Common desktop Linux targets.' },
+                { name: 'macos', summary: 'Common desktop macOS targets.' },
+                { name: 'windows', summary: 'Common desktop Windows targets.' },
+                { name: 'mobile', summary: 'Common mobile and tablet targets.' },
+                { name: 'desktop', summary: 'All common desktop targets.' },
+                { name: 'common', summary: 'All common targets.' },
+                { name: 'extended', summary: 'All supported targets.' }
+            ]
+        };
+    }
+    _platform;
+    _arch;
+    _abi;
+    _target;
+    _outDir;
+    _bundle;
+    _verbose;
+    constructor(argv) {
+        const options = dist_default()(add_target_OPTIONS, { argv, partial: true });
+        this._platform = options.platform || null;
+        this._arch = options.arch || null;
+        this._abi = options.abi || null;
+        this._outDir = options['out-dir'] || external_node_path_namespaceObject.join(process.cwd(), 'dist');
+        this._bundle = options.bundle || null;
+        this._verbose = !!options.verbose;
+        if (options.platform && !options.arch) {
+            throw new Error("Option --platform requires option --arch to be specified as well.");
+        }
+        if (!options.platform && options.arch) {
+            throw new Error("Option --arch requires option --platform to be specified as well.");
+        }
+        if (options.abi && (!options.platform || !options.arch)) {
+            throw new Error("Option --abi requires both options --platform and --arch to be specified as well.");
+        }
+        if (!options.platform && !options.arch && !options.abi) {
+            if (!options._unknown || options._unknown.length === 0) {
+                throw new Error("No arguments found, expected <target> or -p and -a options.");
+            }
+            this._target = options._unknown[0];
+        }
+        else {
+            this._target = `${options.platform}-${options.arch}`;
+            if (!!options.abi) {
+                this._target = `${this._target}-${options.abi}`;
+            }
+        }
+    }
+    log(msg) {
+        if (this._verbose) {
+            console.error("[neon add-target] " + msg);
+        }
+    }
+    async addTarget(sourceManifest) {
+        if (!this._target) {
+            this.log('adding default system target');
+            return optionArray(await sourceManifest.addRustTarget(await getCurrentTarget(msg => this.log(msg))));
+        }
+        else if (isRustTarget(this._target)) {
+            this.log(`adding Rust target ${this._target}`);
+            return optionArray(await sourceManifest.addRustTarget(this._target));
+        }
+        else if (isNodeTarget(this._target)) {
+            this.log(`adding Node target ${this._target}`);
+            return optionArray(await sourceManifest.addNodeTarget(this._target));
+        }
+        else if (isTargetFamilyKey(this._target)) {
+            return sourceManifest.addTargets(expandTargetFamily(this._target));
+        }
+        else {
+            throw new Error(`unrecognized target ${this._target}`);
+        }
+    }
+    async createTemplateTree(sourceManifest, pair) {
+        const { node, rust } = pair;
+        const binaryManifest = sourceManifest.manifestFor(rust);
+        this.log(`prebuild manifest: ${binaryManifest.stringify()}`);
+        const treeDir = external_node_path_namespaceObject.join(this._outDir, node);
+        this.log(`creating ${treeDir}`);
+        await promises_namespaceObject.mkdir(treeDir, { recursive: true });
+        this.log(`created ${treeDir}`);
+        this.log(`creating ${treeDir}/package.json`);
+        await binaryManifest.save(treeDir);
+        this.log(`creating ${treeDir}/README.md`);
+        await promises_namespaceObject.writeFile(external_node_path_namespaceObject.join(treeDir, "README.md"), `# \`${binaryManifest.name}\`\n\n${binaryManifest.description}\n`);
+    }
+    async run() {
+        this.log(`reading package.json`);
+        const sourceManifest = await SourceManifest.load();
+        this.log(`manifest: ${sourceManifest.stringify()}`);
+        const modified = await this.addTarget(sourceManifest);
+        if (modified.length) {
+            sourceManifest.updateTargets(msg => this.log(msg), this._bundle);
+            for (const pair of modified) {
+                await this.createTemplateTree(sourceManifest, pair);
+            }
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ./src/commands/update-targets.ts
+
+
+const update_targets_OPTIONS = [
+    { name: 'bundle', alias: 'b', type: String, defaultValue: null },
+    { name: 'verbose', alias: 'v', type: Boolean, defaultValue: false }
+];
+class UpdateTargets {
+    static summary() { return 'Update dependencies for all build targets in package.json.'; }
+    static syntax() { return 'neon update-targets [-b <file>]'; }
     static options() {
         return [
             { name: '-b, --bundle <file>', summary: 'File to generate bundling metadata.' },
@@ -12561,16 +12811,17 @@ class InstallBuilds {
             { name: 'ncc', summary: '<https://github.com/vercel/ncc>' }
         ];
     }
+    static extraSection() { }
     _bundle;
     _verbose;
     constructor(argv) {
-        const options = dist_default()(install_builds_OPTIONS, { argv });
+        const options = dist_default()(update_targets_OPTIONS, { argv });
         this._bundle = options.bundle || null;
         this._verbose = !!options.verbose;
     }
     log(msg) {
         if (this._verbose) {
-            console.error("[neon install-builds] " + msg);
+            console.error("[neon update-targets] " + msg);
         }
     }
     async run() {
@@ -12579,36 +12830,91 @@ class InstallBuilds {
         const version = sourceManifest.version;
         this.log(`package.json before: ${sourceManifest.stringify()}`);
         this.log(`determined version: ${version}`);
-        const packages = sourceManifest.packageNames();
-        const specs = packages.map(name => `${name}@${version}`);
         if (sourceManifest.upgraded) {
             this.log(`upgrading manifest format`);
             await sourceManifest.save();
         }
-        this.log(`npm install --save-exact -O ${specs.join(' ')}`);
-        const result = await execa('npm', ['install', '--save-exact', '-O', ...specs], { shell: true });
-        if (result.exitCode !== 0) {
-            this.log(`npm failed with exit code ${result.exitCode}`);
-            console.error(result.stderr);
-            process.exit(result.exitCode);
+        sourceManifest.updateTargets(msg => this.log(msg), this._bundle);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/commands/rust-target.ts
+
+
+
+const rust_target_OPTIONS = [
+    { name: 'platform', alias: 'p', type: String, defaultValue: null },
+    { name: 'arch', alias: 'a', type: String, defaultValue: null },
+    { name: 'abi', type: String, defaultValue: null },
+    { name: 'verbose', alias: 'v', type: Boolean, defaultValue: false }
+];
+class RustTarget {
+    static summary() { return 'Look up the Rust target triple for a given build target.'; }
+    static syntax() { return 'neon rust-target <target> | (-p <plat> -a <arch> [--abi <abi>])'; }
+    static options() {
+        return [
+            { name: '<target>', summary: 'Full target name in Node convention.' },
+            { name: '-p, --platform <plat>', summary: 'Target platform name.' },
+            { name: '-a, --arch <arch>', summary: 'Target architecture name.' },
+            { name: '--abi <abi>', summary: 'Target ABI name. (Default: null)' },
+            { name: '-v, --verbose', summary: 'Enable verbose logging. (Default: false)' }
+        ];
+    }
+    static seeAlso() { }
+    static extraSection() { }
+    _platform;
+    _arch;
+    _abi;
+    _target;
+    _verbose;
+    constructor(argv) {
+        const options = dist_default()(rust_target_OPTIONS, { argv, partial: true });
+        this._platform = options.platform || null;
+        this._arch = options.arch || null;
+        this._abi = options.abi || null;
+        this._verbose = !!options.verbose;
+        if (options.platform && !options.arch) {
+            throw new Error("Option --platform requires option --arch to be specified as well.");
         }
-        this.log(`package.json after: ${await promises_namespaceObject.readFile(external_node_path_namespaceObject.join(process.cwd(), "package.json"))}`);
-        if (!this._bundle) {
-            return;
+        if (!options.platform && options.arch) {
+            throw new Error("Option --arch requires option --platform to be specified as well.");
+        }
+        if (options.abi && (!options.platform || !options.arch)) {
+            throw new Error("Option --abi requires both options --platform and --arch to be specified as well.");
+        }
+        let target;
+        if (!options.platform && !options.arch && !options.abi) {
+            if (!options._unknown || options._unknown.length === 0) {
+                throw new Error("No arguments found, expected <target> or -p and -a options.");
+            }
+            target = options._unknown[0];
+        }
+        else {
+            target = `${options.platform}-${options.arch}`;
+            if (!!options.abi) {
+                target = `${target}-${options.abi}`;
+            }
+        }
+        if (!isNodeTarget(target)) {
+            throw new Error(`${target} is not a valid Node target.`);
+        }
+        this._target = target;
+    }
+    log(msg) {
+        if (this._verbose) {
+            console.error("[neon rust-target] " + msg);
         }
-        const PREAMBLE = `// AUTOMATICALLY GENERATED FILE. DO NOT EDIT.
-//
-// This code is never executed but is detected by the static analysis of
-// bundlers such as \`@vercel/ncc\`. The require() expression that selects
-// the right binary module for the current platform is too dynamic to be
-// analyzable by bundler analyses, so this module provides an exhaustive
-// static list for those analyses.
-
-if (0) {
-`;
-        const requires = packages.map(name => `  require('${name}');`).join('\n');
-        this.log(`generating bundler compatibility module at ${this._bundle}`);
-        await promises_namespaceObject.writeFile(this._bundle, PREAMBLE + requires + '\n}\n');
+    }
+    async run() {
+        this.log(`reading package.json`);
+        const sourceManifest = await SourceManifest.load();
+        this.log(`manifest: ${sourceManifest.stringify()}`);
+        const targets = sourceManifest.cfg().targets;
+        const rust = targets[this._target];
+        if (!rust) {
+            throw new Error(`no Rust target found for ${this._target}`);
+        }
+        console.log(rust);
     }
 }
 
@@ -12626,6 +12932,7 @@ class Help {
         ];
     }
     static seeAlso() { }
+    static extraSection() { }
     _name;
     constructor(argv) {
         this._name = argv.length > 0 ? asCommandName(argv[0]) : undefined;
@@ -12649,13 +12956,19 @@ class Help {
 
 
 
+
+
 var CommandName;
 (function (CommandName) {
     CommandName["Help"] = "help";
     CommandName["Dist"] = "dist";
     CommandName["Bump"] = "bump";
     CommandName["PackBuild"] = "pack-build";
+    CommandName["Tarball"] = "tarball";
+    CommandName["AddTarget"] = "add-target";
     CommandName["InstallBuilds"] = "install-builds";
+    CommandName["UpdateTargets"] = "update-targets";
+    CommandName["RustTarget"] = "rust-target";
 })(CommandName || (CommandName = {}));
 ;
 function isCommandName(s) {
@@ -12672,8 +12985,12 @@ const COMMANDS = {
     [CommandName.Help]: Help,
     [CommandName.Dist]: Dist,
     [CommandName.Bump]: Bump,
-    [CommandName.PackBuild]: PackBuild,
-    [CommandName.InstallBuilds]: InstallBuilds
+    [CommandName.PackBuild]: Tarball,
+    [CommandName.Tarball]: Tarball,
+    [CommandName.AddTarget]: AddTarget,
+    [CommandName.InstallBuilds]: UpdateTargets,
+    [CommandName.UpdateTargets]: UpdateTargets,
+    [CommandName.RustTarget]: RustTarget
 };
 function commandFor(name) {
     return COMMANDS[name];
@@ -12683,8 +13000,10 @@ function summaries() {
         { name: CommandName.Help, summary: Help.summary() },
         { name: CommandName.Dist, summary: Dist.summary() },
         { name: CommandName.Bump, summary: Bump.summary() },
-        { name: CommandName.PackBuild, summary: PackBuild.summary() },
-        { name: CommandName.InstallBuilds, summary: InstallBuilds.summary() }
+        { name: CommandName.Tarball, summary: Tarball.summary() },
+        { name: CommandName.AddTarget, summary: AddTarget.summary() },
+        { name: CommandName.UpdateTargets, summary: UpdateTargets.summary() },
+        { name: CommandName.RustTarget, summary: RustTarget.summary() }
     ];
 }
 
@@ -12698,7 +13017,7 @@ __nccwpck_require__.a(module, async (__webpack_handle_async_dependencies__, __we
 /* harmony import */ var command_line_commands__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(5046);
 /* harmony import */ var command_line_commands__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__nccwpck_require__.n(command_line_commands__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _print_js__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(9050);
-/* harmony import */ var _command_js__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(3236);
+/* harmony import */ var _command_js__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(3235);
 /* harmony import */ var node_module__WEBPACK_IMPORTED_MODULE_3__ = __nccwpck_require__(2033);
 /* harmony import */ var node_module__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__nccwpck_require__.n(node_module__WEBPACK_IMPORTED_MODULE_3__);
 
@@ -15721,8 +16040,8 @@ const chalkStderr = createChalk({level: stderrColor ? stderrColor.level : 0});
 
 /* harmony default export */ const chalk_source = (chalk);
 
-// EXTERNAL MODULE: ./src/command.ts + 36 modules
-var command = __nccwpck_require__(3236);
+// EXTERNAL MODULE: ./src/command.ts + 39 modules
+var command = __nccwpck_require__(3235);
 ;// CONCATENATED MODULE: ./src/print.ts
 
 
@@ -15739,6 +16058,9 @@ function yellow(text) {
 function green(text) {
     return chalk_source.bold.greenBright(text);
 }
+function purple(text) {
+    return chalk_source.bold.magentaBright(text);
+}
 function commandUsage(name, command) {
     const sections = [
         {
@@ -15758,6 +16080,10 @@ function commandUsage(name, command) {
     if (seeAlso) {
         sections.push({ header: green('See Also:'), content: seeAlso });
     }
+    const extraSection = command.extraSection();
+    if (extraSection) {
+        sections.push({ header: purple(extraSection.title + ':'), content: extraSection.details });
+    }
     return command_line_usage(sections).trimStart();
 }
 function mainUsage() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neon-rs/cli",
-  "version": "0.0.165",
+  "version": "0.0.167",
   "description": "Command-line build tool for Neon modules.",
   "type": "module",
   "exports": "./index.js",
@@ -27,12 +27,12 @@
   },
   "homepage": "https://github.com/dherman/neon-rs#readme",
   "optionalDependencies": {
-    "@cargo-messages/android-arm-eabi": "0.0.165",
-    "@cargo-messages/darwin-arm64": "0.0.165",
-    "@cargo-messages/darwin-x64": "0.0.165",
-    "@cargo-messages/linux-arm-gnueabihf": "0.0.165",
-    "@cargo-messages/linux-x64-gnu": "0.0.165",
-    "@cargo-messages/win32-arm64-msvc": "0.0.165",
-    "@cargo-messages/win32-x64-msvc": "0.0.165"
+    "@cargo-messages/android-arm-eabi": "0.0.167",
+    "@cargo-messages/darwin-arm64": "0.0.167",
+    "@cargo-messages/darwin-x64": "0.0.167",
+    "@cargo-messages/linux-arm-gnueabihf": "0.0.167",
+    "@cargo-messages/linux-x64-gnu": "0.0.167",
+    "@cargo-messages/win32-arm64-msvc": "0.0.167",
+    "@cargo-messages/win32-x64-msvc": "0.0.167"
   }
 }