chore(workspace): native Rust toolchain as the primary path, builder image as the reproducible alternative

scripts/rust-check.sh and scripts/wasm-build.sh (moved from docker/) run
natively on the user-level rustup toolchain pinned by rust-toolchain.toml;
scripts/rust-env.sh puts ~/.cargo/bin on PATH for non-interactive shells.
Root scripts: rust:check and wasm:build native, rust:check:docker and
wasm:build:docker through docker/rust-run.sh, check:all = scripts/check-all.sh,
the whole pre-merge gate in one command (rust check, types drift, wasm build,
pnpm check, application image, worker:test, worker:image started read-only).
The native check now runs the worker's unit tests (cargo test --workspace);
the sandbox tests stay feature-gated and Docker-only.
This commit is contained in:
bchanot committed 2026-10-13 01:19:13 +02:00
1 parent bd9c7d1968
commit f2cf93668e
12 files changed
+100 -34

No files matched your search

+32
View File
@@ -0,0 +1,32 @@
#!/usr/bin/env bash
# Every technical check a branch must pass before a merge, in one command: `pnpm check:all`.
# It runs on the development machine; no CI is configured on the forge today, and a future
# runner calls these same stages (docs/development/RUST.md §4). Stops at the first failure.
# Needs the native Rust toolchain (RUST.md §1) and Docker for the image stages. The local
# Supabase stack is not required: the SQL suite runs on PGlite inside `pnpm test:run`, and
# `pnpm db:test` is the real-stack complement after a change under supabase/.
set -euo pipefail
cd "$(dirname "$0")/.."
stage() {
printf '\n== %s (%s)\n' "$1" "$(date +%H:%M:%S)"
}
stage "rust: fmt, clippy, tests, ts-rs export, cargo-deny (native toolchain)"
bash scripts/rust-check.sh
stage "rust: committed TypeScript types match the Rust contracts"
git diff --exit-code -- packages/core-wasm/types
stage "wasm: browser module (the core-wasm proofs run on it in the Node pipeline)"
bash scripts/wasm-build.sh
stage "node: typecheck, tests, lint, build"
pnpm check
stage "docker: application image"
docker build -t faunosteo:check .
stage "docker: worker sandbox tests and seccomp derivation on the musl binary that ships"
pnpm worker:test
stage "docker: worker runtime image starts read-only"
pnpm worker:image
docker run --rm --read-only --cap-drop ALL --security-opt no-new-privileges:true \
faunosteo_worker:dev run --check
stage "all checks passed"
+23
View File
@@ -0,0 +1,23 @@
#!/usr/bin/env bash
# The Rust quality gate, one file for every environment: `pnpm rust:check` runs it on the
# native toolchain of the development machine (rustup selects the channel pinned by
# rust-toolchain.toml); `pnpm rust:check:docker` runs the same file inside the reference
# builder image (docker/rust-builder.Dockerfile) when a reproducible run is wanted.
# The worker's sandbox tests are feature-gated (`test-hooks`) and run only in its own
# Alpine/musl image (crates/worker/Dockerfile stage `test`, `pnpm worker:test`): the seccomp
# allowlist is derived for the musl static binary that ships. The plain `cargo test` below
# therefore covers the worker's unit tests and the whole of core and wasm.
set -euo pipefail
cd "$(dirname "$0")/.."
. scripts/rust-env.sh
cargo fmt --all --check
cargo clippy --workspace --all-targets --locked -- -D warnings
cargo test --workspace --locked
# Exports the TypeScript types of the contracts (ts-rs) into packages/core-wasm/types.
# `git diff --exit-code -- packages/core-wasm/types` must stay empty afterwards
# (scripts/check-all.sh, .gitea/workflows/ci.yml): the committed types never drift from
# the Rust structs.
cargo test -p faunosteo-core --features ts --locked
cargo deny check licenses bans sources
+10
View File
@@ -0,0 +1,10 @@
# Sourced by the Rust scripts (never executed): puts the user-level rustup toolchain on
# PATH when the calling shell did not. Non-interactive shells skip ~/.bashrc, so editor
# tasks, git hooks and agent shells start without ~/.cargo/bin. rustup then selects the
# channel pinned by rust-toolchain.toml. Nothing here installs anything.
cargo_bin="${CARGO_HOME:-$HOME/.cargo}/bin"
if ! command -v cargo >/dev/null 2>&1 && [ -x "$cargo_bin/cargo" ]; then
PATH="$cargo_bin:$PATH"
export PATH
fi
unset cargo_bin
+34
View File
@@ -0,0 +1,34 @@
#!/usr/bin/env bash
# Builds the browser module of crates/wasm into packages/core-wasm/pkg (git-ignored).
# `pnpm wasm:build` runs it on the native toolchain (wasm32-unknown-unknown target and the
# wasm-bindgen CLI installed by rustup / cargo install, docs/development/RUST.md §1);
# `pnpm wasm:build:docker` runs the same file inside the reference builder image.
# The wasm-bindgen CLI must be the exact version of the wasm-bindgen crate in Cargo.lock
# (wasm-bindgen >= 0.2.128 refuses a mismatch at runtime; we refuse it up front).
set -euo pipefail
cd "$(dirname "$0")/.."
. scripts/rust-env.sh
lock_version="$(awk '/^name = "wasm-bindgen"$/ { getline; sub(/^version = "/, ""); sub(/"$/, ""); print; exit }' Cargo.lock)"
if ! command -v wasm-bindgen >/dev/null 2>&1; then
echo "wasm-bindgen CLI not found on PATH: cargo install wasm-bindgen-cli --version ${lock_version} --locked" >&2
exit 1
fi
cli_version="$(wasm-bindgen --version | awk '{ print $2 }')"
if [ "$lock_version" != "$cli_version" ]; then
echo "wasm-bindgen crate ${lock_version} (Cargo.lock) != wasm-bindgen-cli ${cli_version} on PATH: cargo install wasm-bindgen-cli --version ${lock_version} --locked" >&2
exit 1
fi
# `proofs`: the R0 trap exports; dropped when R2 builds the module the application ships.
cargo build -p faunosteo-wasm --release --target wasm32-unknown-unknown --locked --features proofs
out=packages/core-wasm/pkg
rm -rf "$out"
wasm-bindgen --target web --out-dir "$out" --out-name faunosteo_wasm \
target/wasm32-unknown-unknown/release/faunosteo_wasm.wasm
raw=$(wc -c < "$out/faunosteo_wasm_bg.wasm")
gz=$(gzip -9 -c "$out/faunosteo_wasm_bg.wasm" | wc -c)
echo "faunosteo_wasm_bg.wasm: ${raw} bytes raw, ${gz} bytes gzip -9"