fuz
fullstack · early · Rust
fuz as this site sees it: what its repo's own files declare, and every record on the coherence and values pages that names it or links it. This page is computed and adds nothing of its own. For what the project is, see the Fuz stack page.
What uses it
The stack repos that declare a dependency on it. A breaking change has to be carried through each of them, and through any consumer that no manifest declares. Only the stack's own projects are listed, so a consumer outside the stack is not here.
| Used by | Kind | Declared in | Through |
|---|---|---|---|
| fuz_forge | runtime | Cargo.toml(path) | fuz_actions, fuz_artifact, fuz_auth, fuz_cell, fuz_cell_actions, fuz_crypto, fuz_db, fuz_db_admin, fuz_fact, fuz_fact_serving, fuz_http, fuz_realtime, fuz_release, fuz_sign, fuz_storage, fuz_sys |
| zap | runtime | Cargo.toml(path) | fuz_eval |
| zzz | runtime | Cargo.toml(path) | fuz_actions, fuz_auth, fuz_db, fuz_http, fuz_pty, fuz_realtime, fuz_sys |
Read from the repos' manifests on . Only each repo's root manifests are read. A manifest shows what a repo declares, which is not always what its code imports, and a dependency that no manifest states, such as a sibling checkout a test reads, is not here. The kind is the manifest table a dependency is declared in, not how much it matters: an app that bundles what it builds declares everything as dev. See every dependency in the stack.
What it declares from outside the stack
- runtime
- Cargo.toml: argh, argon2, axum, base64, blake3, bytes, deadpool-postgres, ed25519-dalek, flate2, futures, futures-util, getrandom, hex, hmac, hyper, hyper-util, libc, lru, nix, notify, parking_lot, postcard, rand, reqwest, rustls, semver, serde, serde_json, sha2, subtle, tar, tempfile, thiserror, time, tokio, tokio-postgres, tokio-util, tower, tower-http, tracing, tracing-appender, tracing-subscriber, tungstenite, url, uuid, zeroize
Read from the repo on . What a repo's manifests declare from outside the stack, by name and without versions. The dev tables are left out, so what an app bundles from its dev table is not here. For a Cargo workspace the list is every crate's together, and it is what is declared, not what a release build links. A crate is left out as tooling only when it is named xtask or testing_*, or the release audit marks it dev-only, so what a bench, debug or test-support crate under another name uses is listed with the rest. See everything the stack declares.
Its check script and CI
It has no package.json. It has a Cargo workspace at its root.
Its CLAUDE.md has no line in a code block that gives gro check or npm run check with a # comment, and none whose comment says to run it before committing.
It may describe its checks another way.
It is among the repos with a Cargo workspace at the root.
.github/workflows/check.yml runs on push (branches main), pull_request (branches **), workflow_dispatch
check on ubuntu-latest
- uses
actions/checkout, pinned to a commit - Install Rust
rustup toolchain install --no-self-update rustup show active-toolchain cargo --version
- uses
Swatinem/rust-cache, pinned to a commit - Format
cargo fmt --all --check
- Clippy
cargo clippy --locked --workspace --all-targets -- -D warnings
- Test
cargo test --locked --workspace
- Test (umask 000)
umask 000 cargo test --locked --workspace
- Release dep-graph audit
cargo xtask check-release
- Rustdoc
cargo doc --locked --workspace --no-deps --all-features --document-private-items
fuzi-gate on ubuntu-latest
- uses
actions/checkout, pinned to a commit - Install Rust
rustup toolchain install --no-self-update rustup show active-toolchain
- uses
Swatinem/rust-cache, pinned to a commit - fuzi empirical gate (glibc)
scripts/fuzi-gate.sh --glibc-only
install-test on ubuntu-latest
- uses
actions/checkout, pinned to a commit - uses
actions/setup-node, pinned to a commit - install.sh end-to-end
scripts/install-test.sh
- install.sh mutation gate
scripts/install-test-mutants.sh
db-tests on ubuntu-latest
- uses
actions/checkout, pinned to a commit - Install Rust
rustup toolchain install --no-self-update rustup show active-toolchain
- uses
Swatinem/rust-cache, pinned to a commit - Create test databases
psql postgres://fuz_test:fuz_test@localhost:5432/fuz_test \ -c 'CREATE DATABASE fuz_db_test;' \ -c 'CREATE DATABASE fuz_auth_test;' \ -c 'CREATE DATABASE fuz_cell_test;' \ -c 'CREATE DATABASE fuz_fact_test;' \ -c 'CREATE DATABASE fuz_fact_serving_test;' \ -c 'CREATE DATABASE fuz_actions_test;' \ -c 'CREATE DATABASE fuz_db_admin_test;' \ -c 'CREATE DATABASE fuz_realtime_test;' \ -c 'CREATE DATABASE fuz_cell_actions_test;'
- DB integration tests
cargo test --locked -p fuz_db -p fuz_http -p fuz_auth -p fuz_cell -p fuz_fact -p fuz_fact_serving -p fuz_actions -p fuz_db_admin -p fuz_realtime -p fuz_cell_actions -- --ignored --test-threads=1
Read from the repo on . A workflow's jobs and steps are as the file writes them: a step's command, or the action it uses without its version. An action's inputs, a matrix's values, permissions, environment and working directories are left out, and nothing here says which command is the gate. A line is quoted when it sits in a code block of the repo's CLAUDE.md, has a # comment after the command, and either is the command gro check or npm run check, or has a comment that says to run it before committing. A repo that describes its check command in a sentence or a list, or in another file, has no line here. Every file is read at the repo's main branch as the checkout last fetched it, so nothing uncommitted or unpushed is here. See every repo's checks.
Holds that name it
- In places: Tool: Oracles, mutants and control cases — Green but wrong
- In places: Tool: Suites that fail on a skip — A gate stops gating
- In places: Tool: Deny rules and dry runs — An unattended session does something irreversible
Comparisons that name it
| Compared | Against | Kind | Runs | Source |
|---|---|---|---|---|
| fuz's package installer | npm | Reference | CI | installer gate |
| fuz_app backend, TypeScript | The fuz spine crates, Rust | Twin | On demand | cross-backend tests |
From Oracles in use.
Gates
- Release audit (every change): A forbidden crate or a test-only feature in a release build, a broken layering rule, and a copied lint table that has drifted. Where: fuz, fuz_forge and zap. pglet runs an audit of its own, for its test-only crate alone.
- Required programs and suites (every change): A suite that passes by skipping: a program a test needs is missing, or a database suite is left off the CI list. Where: zap for programs, fuz for the CI list.
- Mutation gate (ci): A test that passes whether or not the code is right. Where: fuz's install script.
From Gates. A gate is listed here when its row names the project or links its repo, or speaks of a class of repos that the snapshot puts this one in.
Rules that moved down
- Look up the home directory one way became: One hardened function, and in fuz and fuz_forge a lint that refuses the standard one. A direct read of the variable is still only a rule.
From Rules that moved down.
Values
The order fuz states its priorities in, highest first (fuz's values):
- security
- performance
- Cited for how claims are made: fuz's policy to say planned when a thing is not built
- What a reader can verify, content addressing: fuz names a built artifact by the hash of its binaries
- What a reader can verify, content addressing: fuz re-hashes the binaries before every switch to an artifact, and
fuz artifact verifyruns the same check on request - What a reader can verify, signing: fuz checks a release's Ed25519 signature against keys built into the binary, and the installing side links verification only, never the code that signs
- What a reader can verify, signing: fuz's verification flow checks the manifest's signature before any release bytes are fetched, then the hash of the tarball and of each binary, and stops at the first failure
- A limit of what a reader can verify, signing: fuz's docs list the hosted install channel as not yet there: nothing is published to fetch
- A limit of what a reader can verify, signing: On a binary install the built-in key is the root: trusting the first binary means trusting every later release that key signs
- What a reader can verify, reproducible builds: fuz has
fuz artifact build --verify, which rebuilds and compares the output hashes - A limit of what a reader can verify, reproducible builds: fuz lists reproducible builds with attestations from outside rebuilders as deferred
- What a reader can verify, release log: fuz's release log check reads one signed, append-only list of releases from every configured witness, and requires the release to be a row of it with the same hashes, not revoked
- What a reader can verify, release log: Publishing with a log repository named records the release in that list
- A limit of what a reader can verify, release log: The check is implemented and inactive by default: no public release log exists, and nothing happens unless the address of one is set
- A limit of what a reader can verify, release log: Its limits: a bad release becomes public and permanent and is not prevented, and a witness serving an old list hides a newer withdrawal
From the values page.