feat(compression): enable dictionary compression in pure Rust backend

.github/workflows/benchmark.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Generate bot token
         id: bot-token

.github/workflows/coordinode-ci.yml

@@ -59,6 +59,28 @@ jobs:
         working-directory: tools/db_bench
         run: cargo check --all-features
 
+  test-zstd-pure:
+    needs: lint
+    timeout-minutes: 15
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          prefix-key: ubuntu-cargo-zstd-pure
+      - uses: taiki-e/install-action@nextest
+      - name: Clippy (pure backend)
+        run: cargo clippy --no-default-features --features zstd-pure,lz4 --all-targets -- -D warnings
+      - name: Run tests (zstd-pure backend, no C zstd)
+        # zstd_pure_dict integration tests are gated with
+        # #[cfg(all(feature = "zstd-pure", not(feature = "zstd")))], so they
+        # are skipped by --all-features. Run without "zstd" to exercise the
+        # pure Rust dictionary compression path independently.
+        run: cargo nextest run --profile ci --no-default-features --features zstd-pure,lz4
+
   cross:
     needs: lint
     timeout-minutes: 15

README.md

@@ -77,7 +77,6 @@ can be decompressed by the other. When both `zstd` and `zstd-pure` are enabled,
 the C FFI backend takes precedence.
 
 **Current limitations:**
-- Dictionary compression is not yet supported (dictionary decompression works)
 - Decompression throughput is ~2–3.5× slower than the C reference
 
 *Disabled by default.*

src/compression/mod.rs

@@ -22,8 +22,8 @@ use std::sync::Arc;
 /// This trait abstracts the zstd implementation behind a compile-time
 /// selected backend. The C FFI backend (`zstd` feature) provides full
 /// compression levels 1–22 and dictionary support. The pure Rust backend
-/// (`zstd-pure` feature) provides compression levels 1–22 with no C
-/// dependencies (dictionary compression not yet supported).
+/// (`zstd-pure` feature) provides compression levels 1–22 and dictionary
+/// support with no C dependencies.
 ///
 /// Both backends produce RFC 8878 compliant zstd frames, so data
 /// compressed by one can be decompressed by the other.
@@ -35,7 +35,13 @@ pub trait CompressionProvider {
     /// Decompress a zstd frame, pre-allocating `capacity` bytes.
     fn decompress(data: &[u8], capacity: usize) -> crate::Result<Vec<u8>>;
 
-    /// Compress `data` using a pre-trained dictionary.
+    /// Compress `data` using a zstd dictionary.
+    ///
+    /// `dict_raw` may be either a finalized zstd dictionary (magic `0x37A430EC`
+    /// header, entropy tables, content — produced by `zstd --train` or
+    /// [`ZstdDictionary::raw`]) or a raw content dictionary (bare bytes used as
+    /// LZ77 history). Both the C FFI backend and the pure Rust backend accept
+    /// either representation.
     fn compress_with_dict(data: &[u8], level: i32, dict_raw: &[u8]) -> crate::Result<Vec<u8>>;
 
     /// Decompress a zstd frame that was compressed with a dictionary.
@@ -151,9 +157,17 @@ impl ZstdDictionary {
 
     /// Returns a 32-bit dictionary fingerprint (lower 32 bits of xxh3).
     ///
-    /// Intended for display and external interop (e.g., matching against the
-    /// dict ID embedded in a zstd frame header). For internal cache keying
-    /// use [`id64`](ZstdDictionary::id64) to avoid hash collisions.
+    /// Intended for config validation (matching a `CompressionType::ZstdDict`
+    /// `dict_id` against the supplied `ZstdDictionary`) and external interop.
+    ///
+    /// The value is the raw lower 32 bits of xxh3 and may theoretically be `0`
+    /// (probability ≈ 1/2³²). Backends that embed a dict ID in the zstd frame
+    /// header (where id=0 is reserved) are responsible for clamping to at
+    /// least 1 themselves. Config validation is unaffected: both sides derive
+    /// the ID from the same bytes and therefore agree even in the zero case.
+    ///
+    /// For internal cache keying use [`id64`](ZstdDictionary::id64) to avoid
+    /// hash collisions.
     #[must_use]
     #[expect(
         clippy::cast_possible_truncation,