Sans-I/O rewrite: pure state machine + wire codec + async/embedded drivers

.codecov.yml

@@ -2,17 +2,20 @@ codecov:
   require_ci_to_pass: false
 
 ignore:
-  - serf-core/src/serf/base/tests
-  - serf-core/src/serf/base/tests.rs
-  - serf/test
-  - fuzz/
-  - examples/
+  - "**/benches/**"
+  - "**/tests/**"
+  - "**/examples/**"
+  - "**/tests.rs"
 
 coverage:
   status:
     project: # Overall project status
       default:
         target: auto
+        # The driver suites exercise timing-dependent async paths, so repeated
+        # runs of an identical tree differ by a few hit lines; absorb that
+        # measurement noise instead of failing a zero-line diff on a 0.02% dip.
+        threshold: 0.5%
         if_not_found: success
         only_pulls: false
     patch: # Status for the patch in pull requests

.github/workflows/ci-compio.yml

@@ -0,0 +1,95 @@
+name: ci-compio
+
+# The compio async driver: serf-compio's unit tests on compio's single runtime.
+# Nodes bind ephemeral loopback ports, so no subnet setup is required.
+
+on:
+  push:
+    branches:
+      - main
+      - refactor/sansio
+    paths-ignore:
+      - "README.md"
+      - "COPYRIGHT"
+      - "LICENSE*"
+      - "**.md"
+      - "**.txt"
+      - "art"
+  pull_request:
+    paths-ignore:
+      - "README.md"
+      - "COPYRIGHT"
+      - "LICENSE*"
+      - "**.md"
+      - "**.txt"
+      - "art"
+  workflow_dispatch:
+  schedule: [cron: "0 1 */30 * *"]
+
+env:
+  # Every transport plus both AEAD backends, so every gated cell runs. Both AEAD
+  # backends are on so the encryption-validation usability probe sees a present
+  # backend for every SecretKey variant (it trial-encrypts AES and
+  # ChaCha20-Poly1305 keys). compio's own `tls` feature drives the record layer
+  # via compio/rustls; QUIC uses quic-rustls-ring.
+  FEATURES: "tcp,tls,quic-rustls-ring,aes-gcm,chacha20-poly1305,coordinates,tag-regex,tracing,serde,clap,dns,getifs"
+
+jobs:
+  test:
+    name: ${{ matrix.os }} - compio
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly
+          components: clippy, rustfmt
+
+      # Cache BEFORE the build steps so the restore actually warms this run; a
+      # cache placed after the test step only saves, never restores.
+      - name: Cache Cargo registry
+        uses: actions/cache@v6
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}-compio
+
+      - name: Install protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Format
+        run: cargo fmt -p serf-compio --check
+
+      - name: Clippy
+        # --no-deps: lint only our own crate, not its external dependencies.
+        run: cargo clippy -p serf-compio --all-targets --features "$FEATURES" --no-deps -- -D warnings
+
+      - name: Test
+        # --no-fail-fast: run every test binary even if one fails, so a single
+        # OS-specific failure surfaces the rest in the same run.
+        #
+        # Windows runs single-threaded: each compio runtime is single-threaded, so
+        # libtest's default per-core parallelism oversubscribes the CPU and the
+        # SWIM convergence scenarios can miss their timers under the contention.
+        run: |
+          if [ "${{ matrix.os }}" = "windows-latest" ]; then
+            cargo test -p serf-compio --features "$FEATURES" --no-fail-fast -- --test-threads=1
+          else
+            cargo test -p serf-compio --features "$FEATURES" --no-fail-fast
+          fi

.github/workflows/ci-core.yml

@@ -0,0 +1,168 @@
+name: ci-core
+
+# The runtime-independent core: the serf-proto wire codec + Sans-I/O machine
+# and its runtime-agnostic glue crate serf-driver. Both are pure-CPU and bind no
+# sockets.
+
+on:
+  push:
+    branches:
+      - main
+      - refactor/sansio
+    paths-ignore:
+      - "README.md"
+      - "COPYRIGHT"
+      - "LICENSE*"
+      - "**.md"
+      - "**.txt"
+      - "art"
+  pull_request:
+    paths-ignore:
+      - "README.md"
+      - "COPYRIGHT"
+      - "LICENSE*"
+      - "**.md"
+      - "**.txt"
+      - "art"
+  workflow_dispatch:
+  schedule: [cron: "0 1 */30 * *"]
+
+jobs:
+  proto:
+    name: ${{ matrix.os }} - proto
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    env:
+      FEATURES: "tcp,tls,quic-rustls-ring,coordinates,aes-gcm,chacha20-poly1305,tag-regex"
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly
+          components: clippy, rustfmt
+
+      - name: Cache Cargo registry
+        uses: actions/cache@v6
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}-proto
+
+      # serf-proto's build.rs runs protoc (via buffa-build) for the wire codegen,
+      # and its memberlist-proto dependency's build.rs also runs protoc.
+      - name: Install protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Format
+        run: cargo fmt -p serf-proto -p serf-driver --check
+
+      - name: Clippy
+        run: cargo clippy -p serf-proto --all-targets --features "$FEATURES" --no-deps -- -D warnings
+
+      - name: Test
+        run: cargo test -p serf-proto --features "$FEATURES"
+
+  # serf-proto is pure-CPU, so exercise the interesting feature permutations on a
+  # single OS (default, the coordinate + AEAD combos, all-features, the minimal
+  # no_std alloc tier, coordinates+aes+tcp, and quic-rustls-ring alone). A bare
+  # `--no-default-features` build is impossible by design — the crate requires
+  # the `std` or `alloc` tier and fails with a deliberate compile_error — so the
+  # minimal combo pins `alloc`.
+  proto-features:
+    name: proto - ${{ matrix.name }}
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { name: "default", flags: "" }
+          - { name: "coords-aes-gcm", flags: "--features coordinates,aes-gcm" }
+          - { name: "coords-chacha", flags: "--features coordinates,chacha20-poly1305" }
+          - { name: "all-features", flags: "--all-features" }
+          - { name: "no-default", flags: "--no-default-features --features alloc" }
+          - { name: "coords-aes-gcm-tcp", flags: "--features coordinates,aes-gcm,tcp" }
+          - { name: "quic-rustls-ring", flags: "--no-default-features --features quic-rustls-ring" }
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly
+          components: clippy, rustfmt
+
+      - name: Cache Cargo registry
+        uses: actions/cache@v6
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}-proto-features
+
+      - name: Install protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Clippy
+        run: cargo clippy -p serf-proto --all-targets ${{ matrix.flags }} --no-deps -- -D warnings
+
+      - name: Test
+        run: cargo test -p serf-proto ${{ matrix.flags }}
+
+  driver:
+    name: driver
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly
+          components: clippy, rustfmt
+
+      - name: Cache Cargo registry
+        uses: actions/cache@v6
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}-driver
+
+      - name: Install protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Format
+        run: cargo fmt -p serf-driver --check
+
+      - name: Clippy
+        run: cargo clippy -p serf-driver --all-targets --all-features --no-deps -- -D warnings
+
+      - name: Test
+        run: cargo test -p serf-driver --all-features

.github/workflows/ci-smol.yml

@@ -0,0 +1,90 @@
+name: ci-smol
+
+# The reactor async driver under smol. serf-reactor's real-node integration suites
+# (tcp / tls / quic) have runtime-generic scenario bodies with both a `#[tokio::test]`
+# cell (run in ci-tokio) and a `_smol` cell driven by `SmolRuntime::block_on`. This
+# workflow is the smol gate: it clippy-lints the crate with the `smol` runtime feature
+# (proving the `agnostic/smol` code path compiles clean), runs the runtime-independent
+# unit tests, and runs the `_smol` integration cells (`--test {tcp,tls,quic} -- smol`,
+# where `-- smol` selects only the smol cells across the suite binaries). Nodes bind
+# ephemeral loopback ports, so no subnet setup is required.
+
+on:
+  push:
+    branches:
+      - main
+      - refactor/sansio
+    paths-ignore:
+      - "README.md"
+      - "COPYRIGHT"
+      - "LICENSE*"
+      - "**.md"
+      - "**.txt"
+      - "art"
+  pull_request:
+    paths-ignore:
+      - "README.md"
+      - "COPYRIGHT"
+      - "LICENSE*"
+      - "**.md"
+      - "**.txt"
+      - "art"
+  workflow_dispatch:
+  schedule: [cron: "0 1 */30 * *"]
+
+env:
+  FEATURES: "smol,tcp,tls-rustls-ring,quic-rustls-ring,aes-gcm,chacha20-poly1305,coordinates,tag-regex,tracing,serde,clap,dns,getifs,test"
+
+jobs:
+  test:
+    name: ${{ matrix.os }} - reactor - smol
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly
+          components: clippy, rustfmt
+
+      # Cache BEFORE the build steps so the restore actually warms this run; a
+      # cache placed after the test step only saves, never restores.
+      - name: Cache Cargo registry
+        uses: actions/cache@v6
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}-reactor-smol
+
+      - name: Install protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Clippy (smol runtime path)
+        # --no-deps: lint only our own crate, not its external dependencies.
+        run: cargo clippy -p serf-reactor --all-targets --features "$FEATURES" --no-deps -- -D warnings
+
+      - name: Test (runtime-independent unit tests)
+        run: cargo test -p serf-reactor --lib --features "$FEATURES"
+
+      - name: Test (smol integration cells)
+        # `-- smol` selects only the `_smol` cells in each suite binary; the tokio
+        # cells over the same runtime-generic scenarios run in ci-tokio.
+        run: |
+          cargo test -p serf-reactor --features "smol,tcp,tls-rustls-ring,quic-rustls-ring,aes-gcm,chacha20-poly1305,coordinates,tag-regex,dns,getifs,test" --test tcp -- smol
+          cargo test -p serf-reactor --features "smol,tcp,tls-rustls-ring,quic-rustls-ring,aes-gcm,chacha20-poly1305,coordinates,tag-regex,dns,getifs" --test tls -- smol
+          cargo test -p serf-reactor --features "smol,tcp,tls-rustls-ring,quic-rustls-ring,aes-gcm,chacha20-poly1305,coordinates,tag-regex,dns,getifs" --test quic -- smol