@zackees/soldr 0.9.0 → 0.9.2

package/README.md

@@ -70,8 +70,8 @@ The current GitHub Actions entry point is the public `setup-soldr` action:
   with:
     cache: true
 
-- run: soldr cargo build --locked --release
-- run: soldr cargo test --locked
+- run: soldr cargo build --release
+- run: soldr cargo test
 ```
 
 That action:
@@ -91,8 +91,8 @@ For existing workflows where rewriting every `cargo ...` command is high-frictio
   with:
     tool-shims: cargo
 
-- run: cargo build --locked --release
-- run: cargo test --locked
+- run: cargo build --release
+- run: cargo test
 ```
 
 The shim mode is off by default. When enabled, the action resolves the real Cargo binary before prepending its shim directory, then exports that real path for Soldr so `cargo ...` can safely trampoline into `soldr cargo ...` without recursive PATH lookup.
@@ -115,7 +115,7 @@ Two equivalent ways to declare a cross target: declaratively via `rust-toolchain
 ```toml
 # rust-toolchain.toml — declarative (preferred)
 [toolchain]
-channel = "1.94.1"
+channel = "1.95.0"
 targets = ["aarch64-pc-windows-msvc"]
 ```
 
@@ -215,6 +215,32 @@ formatter because Cargo's explicit crate-root argv does not include child
 modules that rustfmt discovers itself. A content-marker shortcut is used only
 for invocations that explicitly set `skip_children=true`.
 
+## Compile C and C++ directly
+
+`soldr cc` and `soldr c++` expose the same catalogue-backed compilers and
+sysroots used by blessed Rust cross-builds. GNU/Linux defaults to the pinned
+glibc 2.17 toolchain:
+
+```bash
+soldr cc --target x86_64-linux-gnu.2.17 hello.c -o hello
+./hello
+```
+
+CMake accepts the command plus its required target arguments through `CC` and
+`CXX`:
+
+```bash
+CC="soldr cc --target x86_64-linux-gnu.2.17" \
+CXX="soldr c++ --target x86_64-linux-gnu.2.17" \
+  cmake -S . -B build
+cmake --build build
+```
+
+Omit `--target` to select the host triple. The first standalone slice supports
+the catalogue GNU/Linux and musl/Linux targets plus
+`x86_64-pc-windows-gnu`. External build tooling can query the prepared tool
+paths with `--print-cc`, `--print-cxx`, `--print-ar`, and `--print-linker`.
+
 ## Use soldr as your PEP 517 build backend (instead of maturin)
 
 For Rust+Python packages, point `pyproject.toml` at soldr instead of
@@ -437,7 +463,7 @@ soldr/
 
 | Crate | Role |
 |---|---|
-| `soldr-core` | Shared types, config (`~/.soldr/config.toml`), target-triple resolution (MSVC default on Windows), the daemon wire schema, error types, the `timed_test!` watchdog. No I/O beyond config files. |
+| `soldr-core` | Shared types, config (`~/.soldr/config.toml`), target-triple resolution (MSVC default on Windows), the daemon wire schema, error types. No I/O beyond config files. |
 | `soldr-fetch` | Binary resolution. `known_tools` registry, `trust` (SHA-256 pins + `SOLDR_TRUST_MODE` enforcement), rustup auto-bootstrap, resolution chain (local cache → repo lookup → GitHub Releases → extract). |
 | `soldr-cache` | `RUSTC_WRAPPER` mode: hash inputs (blake3), check `~/.soldr/cache/`, daemon IPC (Unix socket / Windows named pipe), LRU eviction, `soldr save` / `soldr load` archive transport, auto-GC. |
 | `soldr-daemon` | Daemon lifecycle (spawn/displacement/relocation), IPC server, wire codec, and the embedded zccache service. Depends on `soldr-core` + `soldr-cache`. |

package/contracts/zccache-integration-guardrails.v1.json

@@ -12,52 +12,52 @@
     {
       "id": "rust-embedded-runtime-topology",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --test no_standalone_spawn_lint --locked"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --test no_standalone_spawn_lint"
     },
     {
       "id": "rust-zccache-entry",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --test zccache_trampoline_gate --locked"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --test zccache_trampoline_gate"
     },
     {
       "id": "rust-wrapper-env",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --test cli_cargo_wrappers --locked"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --test cli_cargo_wrappers"
     },
     {
       "id": "rust-rust-plan",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --test cli_rust_plan --locked"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --test cli_rust_plan"
     },
     {
       "id": "rust-cache-cli",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --test cli_cache --locked"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --test cli_cache"
     },
     {
       "id": "rust-cache-session",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --lib --locked cache::session::tests"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --lib cache::session::tests"
     },
     {
       "id": "rust-native-cache-unit",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --lib --locked native_cc::tests"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --lib native_cc::tests"
     },
     {
       "id": "rust-native-cache-integration",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --test cli_cargo_native_cc --locked"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --test cli_cargo_native_cc"
     },
     {
       "id": "rust-wrapper-perf",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --test cli_wrapper_perf --locked"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --test cli_wrapper_perf"
     },
     {
       "id": "rust-watchdog-lint",
       "gate": "hard",
-      "command": "soldr --no-cache cargo test -p soldr-cli --test timed_test_lint --locked"
+      "command": "soldr --no-cache cargo nextest run -p soldr-cli --test no_timed_test_guard"
     },
     {
       "id": "python-setup-contracts",
@@ -321,11 +321,11 @@
       "gate": "hard",
       "covers": [
         "zccache integration tests live outside monolithic source modules",
-        "new tests use the timed_test watchdog",
+        "the removed per-test watchdog does not return (timeouts belong to nextest)",
         "embedded-runtime contract tests remain discoverable"
       ],
       "test_files": [
-        "crates/soldr-cli/tests/timed_test_lint.rs",
+        "crates/soldr-cli/tests/no_timed_test_guard.rs",
         "crates/soldr-cli/tests/no_standalone_spawn_lint.rs",
         "crates/soldr-cli/tests/zccache_trampoline_gate.rs",
         "crates/soldr-cli/src/cargo_front_door/cache_plan.rs"

package/contracts/zccache-runtime.v1.json

@@ -37,7 +37,9 @@
     "manifest_block": "cargo_chef"
   },
   "maturin": {
-    "managed_version": "1.14.1",
+    "managed_version": "1.14.1.post1",
+    "pypi_package": "soldr-maturin",
+    "repository": "zackees/soldr-maturin",
     "required_binaries": [
       "maturin"
     ],

package/package.json

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

package/scripts/install.js

@@ -21,24 +21,15 @@ 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": { triple: "x86_64-unknown-linux-musl", binary: "soldr" },
+  "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" },
   "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
@@ -62,13 +53,6 @@ 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) {
@@ -85,15 +69,7 @@ function compareVersions(left, right) {
   return 0;
 }
 
-// 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:
+// Decide which Linux artifact this host should download. 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
@@ -108,8 +84,13 @@ 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. That property is also exactly why soldr#2453
-// could drop the gnu asset from the release matrix in the first place.
+// 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.
 //
 // `probes` exists so the branches can be tested on any host; the defaults are
 // the real detectors.
@@ -146,24 +127,14 @@ 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)) {
-  void libc;
-  const key = `${platform}-${arch}`;
+  const key =
+    platform === "linux"
+      ? `${platform}-${arch}-${libc || "musl"}`
+      : `${platform}-${arch}`;
   const target = TARGETS[key];
   if (!target) {
-    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.",
-    );
+    throw new Error(`unsupported platform for soldr npm package: ${key}`);
   }
   return target;
 }

package/scripts/test-npm-package.js

@@ -79,58 +79,37 @@ 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");
 
-// 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.
+// Linux: triple selection branches on libc. `platformTarget` accepts an
+// explicit `libc` arg so tests don't depend on the runtime detector.
 assert.strictEqual(
   install.platformTarget("linux", "x64", "gnu").triple,
-  "x86_64-unknown-linux-musl",
+  "x86_64-unknown-linux-gnu",
 );
 assert.strictEqual(
   install.platformTarget("linux", "x64", "musl").triple,
   "x86_64-unknown-linux-musl",
 );
-// An explicitly-unknown libc must still take the runs-anywhere musl build.
+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.
 assert.strictEqual(
   install.platformTarget("linux", "x64", null).triple,
   "x86_64-unknown-linux-musl",
 );
-// 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", "x64").triple, "x86_64-apple-darwin");
 assert.strictEqual(install.platformTarget("darwin", "arm64").triple, "aarch64-apple-darwin");
 assert.strictEqual(install.platformTarget("win32", "x64").triple, "x86_64-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.strictEqual(install.platformTarget("win32", "arm64").triple, "aarch64-pc-windows-msvc");
 assert.throws(() => install.platformTarget("freebsd", "x64"), /unsupported platform/);
 
 // detectLibc must return null on non-Linux platforms so the platform key