RustFS

# MISSION: Scaffold "RustFS" Production Architecture
You are an expert Senior Staff Software Architect and Full-Stack Engineer. Your mission is to scaffold and implement a production-grade, highly reliable, and modular codebase following the proven architecture of **RustFS**.
---
## 1. PROJECT SPECIFICATIONS & BENCHMARK
- **Reference Architecture**: RustFS
- **What It Does**: RustFS is an open-source, S3-compatible distributed object storage system written in Rust, with erasure-coded storage, healing, IAM, KMS-backed encryption, replication and a web console, licensed under Apache-2.0.
- **Domain & Category**: S3-Compatible Object Storage
- **Production Scale**: 20+ people
- **Development Mode**: CLASSIC
- **Architectural Rationale**: RustFS splits a MinIO-style object store into dozens of single-purpose Rust crates behind one binary, keeps extra protocols behind cargo features, and moves inter-node traffic to gRPC, so storage, healing and IAM evolve separately.
- **Live Website Reference**: https://rustfs.com
- **Source Repository**: https://github.com/rustfs/rustfs
---
## 2. PRODUCTION TECH STACK
- **Full Stack Array**: Rust, Tokio, gRPC, S3, Docker, Kubernetes, Helm, OpenTelemetry, Nix
- **Primary Language(s)**: Rust, Shell, Python
- **License of the reference repo**: Apache-2.0
- **Frontend**: Web console — Management console served next to the S3 API; docker-compose.yml exposes it on port 9001 with RUSTFS_CONSOLE_ENABLE.
- **Backend & APIs**: Rust — The whole server is a Cargo workspace of single-purpose crates compiled into the rustfs and rustfs-cli binaries.; Tokio — Async runtime used across the storage, metadata, audit and common crates (rt-multi-thread, fs, sync).; gRPC — tonic in crates/common carries inter-node traffic; message definitions live in crates/protos.; S3 — Primary API: buckets, versioning, object lock, S3 Select, replication and lifecycle, tracked in an S3 compatibility matrix.
- **Data & persistence**: Erasure coding (Reed-Solomon) — crates/ecstore stores objects across erasure sets with redundancy; crates/heal repairs sets and objects.; KMS (Vault / AWS KMS) — Server-side encryption keys come from Vault (KV2 or Transit) or AWS KMS in production; local backends are for testing.
- **Infrastructure & deploy**: Docker — Release image downloads the musl release binary for amd64/arm64; Dockerfile.source builds from source.; Helm — Kubernetes chart under helm/rustfs, packaged by the helm-package.yml workflow.; Nix — flake.nix and nix/rustfs-module.nix provide a reproducible build and a NixOS module.; OpenTelemetry — The server exports telemetry to an OTLP collector via RUSTFS_OBS_ENDPOINT; crates/obs holds the observability code.; GitHub Actions — Dozens of workflows cover CI, S3 conformance tests, MinIO interop, fault tolerance, fuzzing and Docker builds.
- **Tooling, testing & ops**: libFuzzer — fuzz/ targets (bucket validation, archive extraction, local metadata, policy ingress) run via cargo-fuzz.
---
## 3. KEY ARCHITECTURAL DECISIONS (audited from https://github.com/rustfs/rustfs @ edcc81a)
1. **Dozens of single-purpose crates behind one rustfs binary**: The root Cargo.toml workspace lists crates such as ecstore, heal, iam, kms, lock, notify, policy, replication and scanner, each with one job, while rustfs/Cargo.toml builds the rustfs server and rustfs-cli binaries on top of them.
2. **Erasure-coded storage with a separate healing and scanner layer**: crates/ecstore is described as the erasure coding storage backend "with redundancy", and crates/heal handles erasure set and object healing, with crates/scanner and bitrot protection finding what needs repair instead of relying on RAID.
3. **Protocols beyond S3 are cargo features**: rustfs/Cargo.toml enables ftps, webdav and gcs by default; the README marks the OpenStack Swift API and SFTP as opt-in features (--features swift, --features sftp), so the default build carries only what most deployments use.
4. **Nodes talk gRPC over tonic, with shared protobuf definitions**: crates/common depends on tonic with gzip and deflate compression, crates/protos holds the message definitions, and scripts such as run_internode_grpc_ab_bench.sh benchmark the inter-node transport.
5. **MinIO interoperability is tested, but on-disk compatibility is gated**: A minio-interop.yml workflow checks coexistence with MinIO, while reading MinIO-written disks is behind the rio-v2 feature and outside the default build, per the README; objects MinIO encrypted are not readable.
6. **Verification is part of the repository, not an afterthought**: fuzz/ ships libFuzzer targets, .github/workflows runs S3 conformance (e2e-s3tests.yml), fault-tolerance matrices, heal, replication and upgrade tests, and deny.toml gates dependencies with cargo-deny.
---
## 4. NON-NEGOTIABLE ARCHITECTURAL GUARDRAILS
1. **Monorepo & Modular Separation**:
   - Structure as a Turborepo monorepo with strict package boundaries:
     - `apps/web`: Application UI, routing, layouts, and server endpoints.
     - `packages/ui`: Shared design tokens, CSS variables, and Radix UI primitive components.
     - `packages/db`: Database schemas, client singleton, declarative migrations, and seed scripts.
     - `packages/config`: Shared TypeScript, ESLint, and build configurations.
2. **Strict Type Safety & Zero `any` Policy**:
   - Enable `strict: true`, `noImplicitAny: true`, and `strictNullChecks: true`.
   - Validate ALL external inputs, API request bodies, and query parameters with **Zod** schemas before execution.
3. **Frontend & Rendering Guidelines**:
   - Isolate interactive UI state to leaf components. Keep core pages lightweight and performant.
4. **Design System & Aesthetics**:
   - Keep every color, radius, shadow and font in a single token file (CSS variables) and consume tokens everywhere; never hardcode hex values in components.
   - Prefer crisp 1px borders and one subtle shadow scale over blurry default shadows. Pair one sans-serif for body/headings with one monospace for tags, badges, metrics, and code.
5. **Data Layer & Reliability**:
   - Write declarative schema definitions with foreign keys, composite indexes on queried filters, and automated timestamp triggers.
   - Use connection pooling and prepared statements for serverless database execution.
---
## 5. STEP-BY-STEP SCAFFOLDING ROADMAP
- **Phase 1: Workspace & Root Config**: Initialize package manager, monorepo configuration (`turbo.json`, `tsconfig.base.json`, `package.json`).
- **Phase 2: Database Schema & Client**: Set up the data layer (Erasure coding (Reed-Solomon), KMS (Vault / AWS KMS)): client, connection pool, models, and migration scripts.
- **Phase 3: Design Tokens & UI Primitives**: Build accessible `Button`, `Input`, `Card`, `Badge`, and layout wrappers inside `packages/ui`.
- **Phase 4: Core Application Routes & Handlers**: Implement primary authentication, user session handling, and application routes.
- **Phase 5: Quality Assurance & Build Verification**: Run `tsc --noEmit`, ESLint, Prettier, and smoke test suites to ensure zero compilation or runtime errors.
---
## 6. EXECUTION INSTRUCTIONS
1. Review all specifications, architectural guardrails, and stack choices above.
2. Present the full monorepo directory tree structure.
3. Systematically generate the complete, production-ready codebase according to the 5-phase roadmap above — starting with the root workspace setup, followed by the database schema, UI design system package, and full-stack application routes until the repository is fully scaffolded and ready to run.