perf(rust): move pricing snapshots into a leaf crate - #1922

Summary

Most commits that land on main are the scheduled chore(pricing): update models.dev snapshot / update LiteLLM snapshot commits (776 of the last 878 first-parent commits). Each one invalidated the foundation and adapters Crane layers. As a result, every PR opened after one of those commits rebuilt ccusage-core, every adapter, the config-schema generator, and the clippy/hawk/test bases, even when the PR touched no Rust.

This PR moves the snapshot data into a new leaf crate, ccusage-pricing-snapshots. Only the binary depends on it, so a snapshot refresh now changes only the final ccusage derivation (and the test derivation, which builds the whole workspace anyway).

Evidence (before)

I compared drvPaths with nix eval on f6d28c56 (aarch64-darwin), before and after a simulated update:

Causes:

• (a) nix/cargo-artifacts.nix put models-dev-pricing.json and models-dev-catalog-rules.json into every layer's source. ccusage-core/build.rs embeds them, so Cargo reruns the build script and then recompiles ccusage-core and everything that depends on it.
• (b) CCUSAGE_PRICING_JSON_PATH (the litellm input) stayed in artifactCommonArgs. It was only stripped from the deps-only args, so a lock bump changed every layer's environment. ccusage-core's build script also declares rerun-if-env-changed for it.

What changed

• New rust/crates/ccusage-pricing-snapshots: it owns the moved build.rs (unchanged apart from its test import), the committed models-dev-pricing.json / models-dev-catalog-rules.json, and the fetch-litellm-pricing feature. It exports three &[u8] constants and has no runtime dependencies.
• ccusage-core no longer has a build script. It exposes pricing::EmbeddedSnapshots and pricing::set_embedded_snapshots, which main() calls next to the existing set_json_fetcher.
• Tests: a test-only test-snapshots feature on ccusage-core falls back to the snapshot crate when nothing was installed. Crates whose tests load pricing enable it from [dev-dependencies]. Cargo does not activate dev-dependency features for cargo build, so the layers and the shipped binary never compile it.
• nix/cargo-artifacts.nix: layers drop CCUSAGE_PRICING_JSON_PATH and the snapshot JSON. They still include the new crate's manifest and .rs files, because ccusage-core dev-depends on it and Cargo resolves the whole workspace.
• antigravity's stray dev-dependency on ccusage-core/fetch-litellm-pricing is removed. Before this change it pulled the rustls build stack into every cargo test --workspace core build. The binary's fetch-litellm-pricing feature (used by the Windows build) now forwards to the new crate.
• Path updates in justfile (gen-models-dev-pricing), .github/scripts/update-models-dev-lock.nu, nix/treefmt.nix (typos excludes), nix/rust-src.nix, the crate READMEs, and the rust/testing skills.

Evidence (after)

Rebased on 12dfc20e:

The foundation drvPath was also identical before and after rebasing across the real 12dfc20e models.dev snapshot commit. Editing models-dev-catalog-rules.json likewise left foundation/adapters unchanged.

After building .#ccusage, I simulated a snapshot change and rebuilt. Only ccusage-20.0.35.drv was built (36.6s wall locally on a busy machine), with no foundation or adapters derivation. I also listed the foundation/adapters target.tar.zst archives: the only ccusage-pricing-snapshots entries are Crane's dummyBuild ones from the deps layer.

The embedded payload is byte-identical. The deflated litellm-pricing, models-dev-pricing, and models-dev-catalog-rules outputs from ccusage-core's build script at f6d28c56 match the new crate's outputs by SHA-256 (e632d11f…, cf148b37…, 11bf0111…).

Not fixed here: the final layer still rebuilds core and every adapter

While measuring this, I found that the final cargo build -p ccusage --bin ccusage re-checks/recompiles ccusage-core and all adapters even when the layers are fresh. This already happens on main: I reproduced it with cargo check on the same -p sequence the layers use, at f6d28c56. The cause is feature unification. The layer builds resolve features for a subset of the workspace, and the final graph adds e.g. ureq → flate2 → miniz_oxide/simd, syn features from schemars_derive, and libc/default. That changes the metadata hash of serde, miniz_oxide, etc., so ccusage-core becomes a different unit. So for the final binary, this PR saves the layer builds themselves (CI measured foundation 9s + adapters 4.5s on mac-arm64, 33s + 8s on linux-arm64, plus the test job's layer rebuilds and the config-schema generator in preflight). It does not shrink the final layer. Making the layers reusable by the final build (for example a workspace-hack crate, or building the layers with the binary's feature set) is a separate follow-up.

Testing

• nix eval drvPath comparisons above (before/after, both update kinds)
• nix build .#ccusage, then rebuilt after a simulated snapshot change (only the final derivation rebuilt)
• release binary smoke: ccusage daily --offline --json --breakdown --mode calculate prices claude-sonnet-4-20250514 (LiteLLM), claude-opus-4-8, and glm-5 from the embedded snapshots
• cargo fmt --all --check, cargo clippy --workspace --all-targets -- -D warnings, just hawk (0 findings), just fmt (no changes)
• cargo test --workspace with HOME pointed at an empty dir and XDG_DATA_HOME/XDG_CONFIG_HOME/CLAUDE_CONFIG_DIR/CODEX_HOME unset: 1033 passed, 0 failed
• pre-push hooks (clippy, treefmt, gitleaks, cargo test) passed with XDG_DATA_HOME pointed at an empty dir, because the adapter-all tests otherwise read the developer's real OpenCode data

Summary by cubic

Moves pricing snapshot data into a new leaf crate, ccusage-pricing-snapshots, so scheduled snapshot-refresh commits no longer invalidate the foundation and adapters Crane layers. Those commits (776 of the last 878 on main) previously recompiled ccusage-core, every adapter, and the config-schema generator; now a snapshot refresh rebuilds only the final binary derivation. This also cuts CI build and cache time: a minimal rustup profile skips rust-docs (~730 MB), and the macOS and Windows caches are saved only from pushes to main when their dependency keys change.

• The new crate owns the moved build.rs, the committed models.dev JSON snapshots, and the fetch-litellm-pricing feature, and exports three byte constants with no runtime dependencies.
• The binary installs the bytes at startup via pricing::set_embedded_snapshots; ccusage-core keeps the loaders and drops its build script.
• A test-only test-snapshots feature on ccusage-core falls back to the snapshot crate when nothing was installed; crates whose tests load pricing enable it from [dev-dependencies], which Cargo leaves out of cargo build.
• nix/cargo-artifacts.nix no longer injects CCUSAGE_PRICING_JSON_PATH or the snapshot JSON into the layers, so their derivation paths are stable across both kinds of snapshot update.
• Nix flake inputs and the Crane cache root are rooted in the store's gcroots before a macOS save, so each cached entry holds one build closure instead of accumulating every commit's artifacts.
• The Apple and Windows CI jobs install the minimal Rust profile, key Cargo caches on toolchain and manifest hashes rather than the commit, and save only from shared dependency builds on main; the Windows cache drops workspace outputs before saving.

This fixes the layer rebuilds but not the final layer: the last cargo build still recompiles ccusage-core and the adapters due to feature-unification differences between the layer build and the full workspace graph. That already happens on main and is a separate follow-up.

^{Written for commit a36c243. Summary will update on new commits.}