@zackees/soldr 0.8.43 → 0.9.0

package/README.md

@@ -1,12 +1,13 @@
 # Soldr / Rust
 
 
+
 <img width="1536" height="1024" alt="ChatGPT Image Apr 19, 2026, 09_43_32 PM" src="https://github.com/user-attachments/assets/87d94693-3542-4f4f-8b02-600bf0b9810e" />
 
+*Beta software, please pin*
 
 *A tool to download rust tool sets and aggressive cache your build. **2× faster cross-PR builds** via content-addressed caching that swatinem's per-key cache cannot share. GH and local builds. Just add soldr before all your build commands.*
 
-Third-party comparison (soldr vs Swatinem/rust-cache vs ...): published from `zackees/setup-soldr` — see its `comparison-cluster` workflow and the rendered page once the migration in soldr#674 completes. The legacy `https://zackees.github.io/soldr/` page is being repurposed for soldr-internal per-scenario regression history (no third-party comparison surface lives on this repo anymore).
 
 [![CI](https://github.com/zackees/soldr/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/zackees/soldr/actions/workflows/ci.yml)
 [![Autonomous Release](https://github.com/zackees/soldr/actions/workflows/release-auto.yml/badge.svg?branch=main)](https://github.com/zackees/soldr/actions/workflows/release-auto.yml)
@@ -187,7 +188,6 @@ If soldr solves that one problem well, it becomes a super tool: the command you
 # Build through soldr's front door:
 soldr cargo build --release
 soldr cargo test
-soldr --no-cache cargo test
 soldr purge
 SOLDR_RUSTC_WRAPPER=sccache soldr cargo build
 SOLDR_RUSTC_WRAPPER=none soldr cargo build
@@ -404,7 +404,7 @@ If you also have many separate test binaries, consider consolidating them under
 
 - **One obvious command**: Fetch tools, pick the right Windows target, and run through Soldr's embedded zccache service through the same entry point.
 - **Front-door builds**: `soldr cargo ...` is the primary build UX.
-- **Invisible caching**: `soldr cargo ...` uses the zccache service embedded in `soldr-daemon` by default, with `soldr --no-cache cargo ...` as the opt-out.
+- **Broker-owned caching**: `soldr cargo ...` uses the zccache service embedded in a broker-placed `soldr-daemon`; cacheable compiler work has one mandatory route.
 - **Real cache controls**: `soldr status`, `soldr cache`, and `soldr clean` report and manage embedded-zccache state, while `soldr purge` removes all Soldr-managed cache artifacts for bug clearing and benchmarking.
 - **One cache boundary**: official soldr keeps its tools and cache state under `~/.soldr/`; development builds use `~/.soldr-dev/`. Use `SOLDR_CACHE_DIR` to select an explicit root.
 - **Bounded while idle**: the long-lived daemon owns only its selected root,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zackees/soldr",
-  "version": "0.8.43",
+  "version": "0.9.0",
   "description": "Instant Rust tools and builds from one command.",
   "license": "BSD-3-Clause",
   "homepage": "https://github.com/zackees/soldr",

package/scripts/install.js

@@ -21,15 +21,24 @@ const PACKAGE_JSON = require(path.join(PACKAGE_ROOT, "package.json"));
 // through the managed-download path.
 const ARCHIVE_EXT = zccacheContract.ARCHIVE_EXT;
 
+// soldr#2453: the Autonomous Release matrix was reduced to exactly 3
+// published native targets. x86_64 Linux ships only the statically-linked
+// musl binary -- it is verified statically linked before staging
+// (release-auto.yml -> "Verify musl binary is statically linked"), so it
+// has no dynamic loader dependency and is the universal x86_64-linux
+// artifact, running on glibc hosts too. There is no separate gnu-linux
+// asset in this release, so the `-gnu` / `-musl` key split that used to
+// exist for linux-x64 is gone: any x86_64 Linux host, on either libc,
+// resolves to the single entry keyed `linux-x64` below -- there is no
+// glibc-version gate on this selection. arm64 Linux (gnu and musl), Intel
+// macOS (darwin-x64), and Windows arm64 are not published in this release
+// and are intentionally absent from this map -- platformTarget() throws a
+// clear error for them instead of letting a lookup miss fall through to a
+// 404 download.
 const TARGETS = {
-  "linux-x64-gnu": { triple: "x86_64-unknown-linux-gnu", binary: "soldr" },
-  "linux-x64-musl": { triple: "x86_64-unknown-linux-musl", binary: "soldr" },
-  "linux-arm64-gnu": { triple: "aarch64-unknown-linux-gnu", binary: "soldr" },
-  "linux-arm64-musl": { triple: "aarch64-unknown-linux-musl", binary: "soldr" },
-  "darwin-x64": { triple: "x86_64-apple-darwin", binary: "soldr" },
+  "linux-x64": { triple: "x86_64-unknown-linux-musl", binary: "soldr" },
   "darwin-arm64": { triple: "aarch64-apple-darwin", binary: "soldr" },
   "win32-x64": { triple: "x86_64-pc-windows-msvc", binary: "soldr.exe" },
-  "win32-arm64": { triple: "aarch64-pc-windows-msvc", binary: "soldr.exe" },
 };
 
 // Files we expect to find at the root of every extracted release
@@ -53,6 +62,13 @@ const BUNDLED_BINARIES = zccacheContract.RELEASE_BUNDLED_BINARIES;
 // Kept in lockstep with the `--max-glibc` ceiling in release-auto.yml by a
 // check in test-npm-package.js. When the release build is fixed to link
 // against a 2.17 baseline that ceiling drops, and this must follow it down.
+//
+// soldr#2453: no gnu-linux asset is published anymore (see TARGETS above),
+// so this constant no longer selects anything in platformTarget() -- every
+// x86_64 Linux host takes the musl asset regardless of glibc version. It is
+// kept, unchanged, only because test-npm-package.js still asserts it stays
+// in lockstep with the `--max-glibc` value release-auto.yml passes to
+// verify_glibc_baseline.py, and detectLibc() below still consults it.
 const MIN_GLIBC_FOR_GNU = "2.39";
 
 function compareVersions(left, right) {
@@ -69,7 +85,15 @@ function compareVersions(left, right) {
   return 0;
 }
 
-// Decide which Linux artifact this host should download. Ordered probes:
+// Classify this host's libc family. Before soldr#2453 this decided which
+// Linux artifact to download (gnu vs musl); now that the release matrix
+// publishes only the musl x86_64-linux asset, platformTarget() below no
+// longer branches on the result -- every linux-x64 host takes the musl
+// download regardless of libc. The detector itself is kept (and still
+// covered directly by test-npm-package.js, and still consulted by
+// MIN_GLIBC_FOR_GNU's own lockstep bookkeeping) since it remains an
+// accurate, independently useful "what libc is this host" probe. Ordered
+// probes:
 //
 //   1. A musl loader in /lib means the SYSTEM is musl, and that outranks
 //      whatever Node was linked against. This has to run first: a glibc Node
@@ -84,13 +108,8 @@ function compareVersions(left, right) {
 // musl is the safe end of every unknown because that artifact is verified
 // statically linked before it is ever staged (release-auto.yml → "Verify musl
 // binary is statically linked"), so it has no dynamic loader dependency and
-// runs on glibc hosts too. The mistakes are not symmetric:
-//
-//   pick musl, actually glibc      → works, nothing to resolve
-//   pick gnu,  actually musl       → hard failure, "soldr: not found"
-//   pick gnu,  glibc too old       → hard failure, "GLIBC_2.39 not found"
-//
-// Only the first is recoverable.
+// runs on glibc hosts too. That property is also exactly why soldr#2453
+// could drop the gnu asset from the release matrix in the first place.
 //
 // `probes` exists so the branches can be tested on any host; the defaults are
 // the real detectors.
@@ -127,14 +146,24 @@ function detectLibc(platform = process.platform, probes = {}) {
   return "musl";
 }
 
+// soldr#2453: the release matrix publishes exactly 3 native targets, so
+// resolution is a flat `<platform>-<arch>` lookup -- linux no longer keys
+// on libc because both families download the same musl asset (see TARGETS
+// above), and there is no glibc-version gate on that download. The `libc`
+// parameter is still accepted (and still defaults to detectLibc()) purely
+// for call-site/back-compat with existing callers and tests; it plays no
+// role in which target is returned.
 function platformTarget(platform = process.platform, arch = process.arch, libc = detectLibc(platform)) {
-  const key =
-    platform === "linux"
-      ? `${platform}-${arch}-${libc || "musl"}`
-      : `${platform}-${arch}`;
+  void libc;
+  const key = `${platform}-${arch}`;
   const target = TARGETS[key];
   if (!target) {
-    throw new Error(`unsupported platform for soldr npm package: ${key}`);
+    throw new Error(
+      `unsupported platform for soldr npm package: ${key}. This soldr release ` +
+        "publishes prebuilt binaries only for x86_64 Linux, Apple Silicon macOS " +
+        `(arm64), and x86_64 Windows. ${key} is not currently supported by a ` +
+        "prebuilt binary.",
+    );
   }
   return target;
 }

package/scripts/test-npm-package.js

@@ -79,37 +79,58 @@ assert.deepStrictEqual(pkg.files, [
 const bin = fs.readFileSync(path.join(root, pkg.bin.soldr), "utf8");
 assert(bin.startsWith("#!/usr/bin/env node"), "bin/soldr.js must have a node shebang");
 
-// Linux: triple selection branches on libc. `platformTarget` accepts an
-// explicit `libc` arg so tests don't depend on the runtime detector.
+// soldr#2453: the Autonomous Release matrix publishes exactly 3 native
+// targets -- x86_64 Linux (musl, universal for glibc hosts too), Apple
+// Silicon macOS, and x86_64 Windows. `platformTarget` accepts an explicit
+// `libc` arg so tests don't depend on the runtime detector, but linux-x64
+// no longer branches on it: both libc families resolve to the same musl
+// asset because there is no separate gnu-linux release asset, and no
+// glibc-version gate, anymore.
 assert.strictEqual(
   install.platformTarget("linux", "x64", "gnu").triple,
-  "x86_64-unknown-linux-gnu",
+  "x86_64-unknown-linux-musl",
 );
 assert.strictEqual(
   install.platformTarget("linux", "x64", "musl").triple,
   "x86_64-unknown-linux-musl",
 );
-assert.strictEqual(
-  install.platformTarget("linux", "arm64", "gnu").triple,
-  "aarch64-unknown-linux-gnu",
-);
-assert.strictEqual(
-  install.platformTarget("linux", "arm64", "musl").triple,
-  "aarch64-unknown-linux-musl",
-);
-// Default (no libc arg) falls back to detectLibc; on most CI hosts that's
-// gnu. We don't assert the triple here — just that the call resolves.
-assert.ok(install.platformTarget("linux", "x64").triple.startsWith("x86_64-unknown-linux-"));
-// An explicitly-unknown libc must take the runs-anywhere build, matching
-// detectLibc's own unknown case rather than contradicting it.
+// An explicitly-unknown libc must still take the runs-anywhere musl build.
 assert.strictEqual(
   install.platformTarget("linux", "x64", null).triple,
   "x86_64-unknown-linux-musl",
 );
-assert.strictEqual(install.platformTarget("darwin", "x64").triple, "x86_64-apple-darwin");
+// Default (no libc arg) falls back to detectLibc; either family still
+// resolves to the musl asset.
+assert.strictEqual(install.platformTarget("linux", "x64").triple, "x86_64-unknown-linux-musl");
+
+// arm64 Linux has no published asset in this release, for either libc
+// family -- must throw a clear, actionable error rather than attempt a
+// download that 404s.
+assert.throws(
+  () => install.platformTarget("linux", "arm64", "gnu"),
+  /unsupported platform/,
+  "linux-arm64 (gnu) has no published asset and must throw",
+);
+assert.throws(
+  () => install.platformTarget("linux", "arm64", "musl"),
+  /unsupported platform/,
+  "linux-arm64 (musl) has no published asset and must throw",
+);
+
 assert.strictEqual(install.platformTarget("darwin", "arm64").triple, "aarch64-apple-darwin");
 assert.strictEqual(install.platformTarget("win32", "x64").triple, "x86_64-pc-windows-msvc");
-assert.strictEqual(install.platformTarget("win32", "arm64").triple, "aarch64-pc-windows-msvc");
+
+// Intel macOS and Windows arm64 have no published asset in this release.
+assert.throws(
+  () => install.platformTarget("darwin", "x64"),
+  /unsupported platform/,
+  "darwin-x64 (Intel mac) has no published asset and must throw",
+);
+assert.throws(
+  () => install.platformTarget("win32", "arm64"),
+  /unsupported platform/,
+  "win32-arm64 has no published asset and must throw",
+);
 assert.throws(() => install.platformTarget("freebsd", "x64"), /unsupported platform/);
 
 // detectLibc must return null on non-Linux platforms so the platform key