From 332fc198bb165835a3680b009470b23e32dacb99 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 20 Jul 2025 05:33:03 +0000
Subject: [PATCH 1/9] Initial plan


From f752d7a67cc145e41bd05d1dee76556be95d0842 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 20 Jul 2025 05:53:52 +0000
Subject: [PATCH 2/9] Add zstd compression support

Co-authored-by: SeriousBug <1008124+SeriousBug@users.noreply.github.com>
---
 Cargo.toml                |  6 ++++++
 README.md                 |  6 +++---
 impl/Cargo.toml           |  1 +
 impl/src/attributes.rs    |  1 +
 impl/src/compress.rs      | 19 +++++++++++++++++++
 impl/src/embed.rs         |  8 +++++++-
 impl/src/lib.rs           |  2 +-
 tests/compression.rs      | 10 ++++++++++
 tests/zstd.rs             | 39 +++++++++++++++++++++++++++++++++++++++
 utils/src/config.rs       | 10 ++++++++++
 utils/src/file/common.rs  |  6 ++++++
 utils/src/file/dynamic.rs |  4 ++++
 utils/src/file/embed.rs   |  7 +++++++
 13 files changed, 114 insertions(+), 5 deletions(-)
 create mode 100644 tests/zstd.rs

diff --git a/Cargo.toml b/Cargo.toml
index 6ad7ac6..9cf4257 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,6 +19,7 @@ rust-embed-for-web-utils = { version = "11.2.1", path = "utils" }
 chrono = { version = "0.4", default-features = false }
 flate2 = "1.0"
 brotli = "6.0"
+zstd = "0.13"
 actix-web = "4.4"
 
 [features]
@@ -46,6 +47,11 @@ name = "gzip"
 path = "tests/gzip.rs"
 required-features = ["always-embed"]
 
+[[test]]
+name = "zstd"
+path = "tests/zstd.rs"
+required-features = ["always-embed"]
+
 [[test]]
 name = "include-exclude"
 path = "tests/include-exclude.rs"
diff --git a/README.md b/README.md
index e056db5..7223d21 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,7 @@ executable in exchange for better performance at runtime. In particular:
   or decompress anything at runtime.
   - If the compression makes little difference, for example a jpeg file won't
     compress much further if at all, then the compressed version is not included.
-  - You can also disable this behavior by adding an attribute `#[gzip = false]` and `#[br = false]`
+  - You can also disable this behavior by adding an attribute `#[gzip = false]`, `#[br = false]`, or `#[zstd = false]`
     When disabled, the compressed files won't be included for that embed.
 - Some metadata that is useful for web headers like `ETag` and `Last-Modified`
   are computed ahead of time and embedded into the executable. This makes it
@@ -68,8 +68,8 @@ The path for the `folder` is resolved relative to where `Cargo.toml` is.
 
 ### Disabling compression
 
-You can add `#[gzip = false]` and/or `#[br = false]` attributes to your embed to
-disable gzip and brotli compression for the files in that embed.
+You can add `#[gzip = false]`, `#[br = false]`, and/or `#[zstd = false]` attributes to your embed to
+disable gzip, brotli, and/or zstd compression for the files in that embed.
 `rust-embed-for-web` will only include compressed files where the compression
 actually makes files smaller so files that won't compress well like images or
 archives already don't include their compressed versions. However you can
diff --git a/impl/Cargo.toml b/impl/Cargo.toml
index 098a502..a598e05 100644
--- a/impl/Cargo.toml
+++ b/impl/Cargo.toml
@@ -27,6 +27,7 @@ walkdir = "2.4.0"
 # Compression
 flate2 = "1.0"
 brotli = "6.0"
+zstd = "0.13"
 
 globset = { version = "0.4", optional = true }
 
diff --git a/impl/src/attributes.rs b/impl/src/attributes.rs
index 42dec84..9068311 100644
--- a/impl/src/attributes.rs
+++ b/impl/src/attributes.rs
@@ -42,6 +42,7 @@ pub(crate) fn read_attribute_config(ast: &syn::DeriveInput) -> Config {
                 "exclude" => parse_str(attribute).map(|v| config.add_exclude(v)),
                 "gzip" => parse_bool(attribute).map(|v| config.set_gzip(v)),
                 "br" => parse_bool(attribute).map(|v| config.set_br(v)),
+                "zstd" => parse_bool(attribute).map(|v| config.set_zstd(v)),
                 _ => None,
             };
         }
diff --git a/impl/src/compress.rs b/impl/src/compress.rs
index a0a8ff0..b20495c 100644
--- a/impl/src/compress.rs
+++ b/impl/src/compress.rs
@@ -2,6 +2,7 @@ use std::io::{BufReader, Write};
 
 use brotli::enc::BrotliEncoderParams;
 use flate2::{write::GzEncoder, Compression};
+use zstd::stream::write::Encoder as ZstdEncoder;
 
 /// Only include the compressed version if it is at least this much smaller than
 /// the uncompressed version.
@@ -39,3 +40,21 @@ pub(crate) fn compress_br(data: &[u8]) -> Option<Vec<u8>> {
         None
     }
 }
+
+pub(crate) fn compress_zstd(data: &[u8]) -> Option<Vec<u8>> {
+    let mut data_zstd: Vec<u8> = Vec::new();
+    let mut encoder = ZstdEncoder::new(&mut data_zstd, 3)
+        .expect("Failed to create zstd encoder");
+    encoder
+        .write_all(data)
+        .expect("Failed to compress zstd data");
+    encoder
+        .finish()
+        .expect("Failed to finish compression of zstd data");
+
+    if data_zstd.len() < ((data.len() as f64) * COMPRESSION_INCLUDE_THRESHOLD) as usize {
+        Some(data_zstd)
+    } else {
+        None
+    }
+}
diff --git a/impl/src/embed.rs b/impl/src/embed.rs
index 6b775ee..7c777c6 100644
--- a/impl/src/embed.rs
+++ b/impl/src/embed.rs
@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream as TokenStream2;
 use rust_embed_for_web_utils::{get_files, Config, DynamicFile, EmbedableFile, FileEntry};
 
-use crate::compress::{compress_br, compress_gzip};
+use crate::compress::{compress_br, compress_gzip, compress_zstd};
 
 /// Anything that can be embedded into the program.
 ///
@@ -70,6 +70,11 @@ impl<'t> MakeEmbed for EmbedDynamicFile<'t> {
         } else {
             None::<Vec<u8>>.make_embed()
         };
+        let data_zstd = if self.config.should_zstd() {
+            compress_zstd(&data).make_embed()
+        } else {
+            None::<Vec<u8>>.make_embed()
+        };
         let data = data.make_embed();
         let hash = file.hash().make_embed();
         let etag = file.etag().make_embed();
@@ -83,6 +88,7 @@ impl<'t> MakeEmbed for EmbedDynamicFile<'t> {
                 #data,
                 #data_gzip,
                 #data_br,
+                #data_zstd,
                 #hash,
                 #etag,
                 #last_modified,
diff --git a/impl/src/lib.rs b/impl/src/lib.rs
index 4484382..80cbcfb 100644
--- a/impl/src/lib.rs
+++ b/impl/src/lib.rs
@@ -87,7 +87,7 @@ fn impl_rust_embed_for_web(ast: &syn::DeriveInput) -> TokenStream2 {
     }
 }
 
-#[proc_macro_derive(RustEmbed, attributes(folder, prefix, include, exclude, gzip, br))]
+#[proc_macro_derive(RustEmbed, attributes(folder, prefix, include, exclude, gzip, br, zstd))]
 /// A folder that is embedded into your program.
 ///
 /// For example:
diff --git a/tests/compression.rs b/tests/compression.rs
index dcf5a68..220b529 100644
--- a/tests/compression.rs
+++ b/tests/compression.rs
@@ -11,6 +11,7 @@ struct Embed;
 fn html_files_are_compressed() {
     assert!(Embed::get("index.html").unwrap().data_gzip().is_some());
     assert!(Embed::get("index.html").unwrap().data_br().is_some());
+    assert!(Embed::get("index.html").unwrap().data_zstd().is_some());
 }
 
 #[test]
@@ -20,6 +21,7 @@ fn image_files_are_not_compressed() {
         .data_gzip()
         .is_none());
     assert!(Embed::get("images/flower.jpg").unwrap().data_br().is_none());
+    assert!(Embed::get("images/flower.jpg").unwrap().data_zstd().is_none());
 }
 
 #[test]
@@ -42,3 +44,11 @@ fn compression_br_roundtrip() {
     let decompressed_body = String::from_utf8_lossy(&decompressed[..]);
     assert!(decompressed_body.starts_with("<!DOCTYPE html>"));
 }
+
+#[test]
+fn compression_zstd_roundtrip() {
+    let compressed = Embed::get("index.html").unwrap().data_zstd().unwrap();
+    let decompressed = zstd::bulk::decompress(&compressed, 1024 * 1024).unwrap();
+    let decompressed_body = String::from_utf8_lossy(&decompressed[..]);
+    assert!(decompressed_body.starts_with("<!DOCTYPE html>"));
+}
diff --git a/tests/zstd.rs b/tests/zstd.rs
new file mode 100644
index 0000000..8784bc7
--- /dev/null
+++ b/tests/zstd.rs
@@ -0,0 +1,39 @@
+use rust_embed_for_web::{EmbedableFile, RustEmbed};
+
+#[derive(RustEmbed)]
+#[folder = "examples/public/"]
+struct DefaultZstd;
+
+#[derive(RustEmbed)]
+#[folder = "examples/public/"]
+#[zstd = false]
+struct FalseZstd;
+
+#[derive(RustEmbed)]
+#[folder = "examples/public/"]
+#[zstd = true]
+struct TrueZstd;
+
+#[test]
+fn zstd_is_used_by_default() {
+    let file = DefaultZstd::get("index.html").unwrap();
+    assert!(file.data_zstd().is_some());
+}
+
+#[test]
+fn zstd_is_used_when_enabled() {
+    let file = TrueZstd::get("index.html").unwrap();
+    assert!(file.data_zstd().is_some());
+}
+
+#[test]
+fn zstd_is_not_available_when_disabled() {
+    let file = FalseZstd::get("index.html").unwrap();
+    assert!(file.data_zstd().is_none());
+}
+
+#[test]
+fn image_files_dont_get_zstd_compressed() {
+    let file = DefaultZstd::get("images/flower.jpg").unwrap();
+    assert!(file.data_zstd().is_none());
+}
\ No newline at end of file
diff --git a/utils/src/config.rs b/utils/src/config.rs
index d4571da..bc74f77 100644
--- a/utils/src/config.rs
+++ b/utils/src/config.rs
@@ -9,6 +9,7 @@ pub struct Config {
     exclude: Vec<GlobMatcher>,
     gzip: bool,
     br: bool,
+    zstd: bool,
 }
 
 impl Default for Config {
@@ -20,6 +21,7 @@ impl Default for Config {
             exclude: vec![],
             gzip: true,
             br: true,
+            zstd: true,
         }
     }
 }
@@ -56,6 +58,10 @@ impl Config {
         self.br = status;
     }
 
+    pub fn set_zstd(&mut self, status: bool) {
+        self.zstd = status;
+    }
+
     #[cfg(feature = "include-exclude")]
     pub fn get_includes(&self) -> &Vec<GlobMatcher> {
         &self.include
@@ -99,4 +105,8 @@ impl Config {
     pub fn should_br(&self) -> bool {
         self.br
     }
+
+    pub fn should_zstd(&self) -> bool {
+        self.zstd
+    }
 }
diff --git a/utils/src/file/common.rs b/utils/src/file/common.rs
index 44b7615..f7b4684 100644
--- a/utils/src/file/common.rs
+++ b/utils/src/file/common.rs
@@ -37,6 +37,12 @@ pub trait EmbedableFile {
     /// not precompressed, either because the file doesn't benefit from
     /// compression or because gzip was disabled with `#[br = false]`.
     fn data_br(&self) -> Option<Self::Data>;
+    /// The contents of the file, compressed with zstd.
+    ///
+    /// This is `Some` if precompression has been done. `None` if the file was
+    /// not precompressed, either because the file doesn't benefit from
+    /// compression or because zstd was disabled with `#[zstd = false]`.
+    fn data_zstd(&self) -> Option<Self::Data>;
     /// The UNIX timestamp of when the file was last modified.
     fn last_modified_timestamp(&self) -> Option<i64>;
     /// The rfc2822 encoded last modified date. This is the format you use for
diff --git a/utils/src/file/dynamic.rs b/utils/src/file/dynamic.rs
index 527b71a..a541311 100644
--- a/utils/src/file/dynamic.rs
+++ b/utils/src/file/dynamic.rs
@@ -48,6 +48,10 @@ impl EmbedableFile for DynamicFile {
         None
     }
 
+    fn data_zstd(&self) -> Option<Self::Data> {
+        None
+    }
+
     fn last_modified(&self) -> Option<Self::Meta> {
         self.last_modified_timestamp()
             .map(|v| chrono::Utc.timestamp_opt(v, 0).unwrap().to_rfc2822())
diff --git a/utils/src/file/embed.rs b/utils/src/file/embed.rs
index 9878671..14b5275 100644
--- a/utils/src/file/embed.rs
+++ b/utils/src/file/embed.rs
@@ -15,6 +15,7 @@ pub struct EmbeddedFile {
     data: &'static [u8],
     data_gzip: Option<&'static [u8]>,
     data_br: Option<&'static [u8]>,
+    data_zstd: Option<&'static [u8]>,
     hash: &'static str,
     etag: &'static str,
     last_modified: Option<&'static str>,
@@ -42,6 +43,10 @@ impl EmbedableFile for EmbeddedFile {
         self.data_br
     }
 
+    fn data_zstd(&self) -> Option<Self::Data> {
+        self.data_zstd
+    }
+
     fn last_modified(&self) -> Option<Self::Meta> {
         self.last_modified
     }
@@ -76,6 +81,7 @@ impl EmbeddedFile {
         data: &'static [u8],
         data_gzip: Option<&'static [u8]>,
         data_br: Option<&'static [u8]>,
+        data_zstd: Option<&'static [u8]>,
         hash: &'static str,
         etag: &'static str,
         last_modified: Option<&'static str>,
@@ -87,6 +93,7 @@ impl EmbeddedFile {
             data,
             data_gzip,
             data_br,
+            data_zstd,
             hash,
             etag,
             last_modified,

From 1b54b58f35c431cba351be27aa5bc931f0103a5b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 20 Jul 2025 07:25:45 +0000
Subject: [PATCH 3/9] Add test coverage for DynamicFile compression methods and
 fix clippy warning

Co-authored-by: SeriousBug <1008124+SeriousBug@users.noreply.github.com>
---
 tests/dynamic.rs | 35 +++++++++++++++++++++++++++++++++++
 utils/src/lib.rs |  2 +-
 2 files changed, 36 insertions(+), 1 deletion(-)
 create mode 100644 tests/dynamic.rs

diff --git a/tests/dynamic.rs b/tests/dynamic.rs
new file mode 100644
index 0000000..3b1a200
--- /dev/null
+++ b/tests/dynamic.rs
@@ -0,0 +1,35 @@
+use rust_embed_for_web::{EmbedableFile, RustEmbed};
+
+// This test is designed to run in debug mode without always-embed feature
+// to test the DynamicFile code paths that always return None for compressed data
+#[derive(RustEmbed)]
+#[folder = "examples/public/"]
+struct DynamicAssets;
+
+#[test]
+fn dynamic_file_compressed_data_is_none() {
+    // In debug mode without always-embed, this should use DynamicFile
+    let file = DynamicAssets::get("index.html").unwrap();
+    
+    // DynamicFile always returns None for compressed data
+    assert!(file.data_gzip().is_none());
+    assert!(file.data_br().is_none());
+    assert!(file.data_zstd().is_none());
+    
+    // But it should still have the original data
+    assert!(!file.data().is_empty());
+}
+
+#[test]
+fn dynamic_file_image_compressed_data_is_none() {
+    // Test with an image file too
+    let file = DynamicAssets::get("images/flower.jpg").unwrap();
+    
+    // DynamicFile always returns None for compressed data
+    assert!(file.data_gzip().is_none());
+    assert!(file.data_br().is_none());
+    assert!(file.data_zstd().is_none());
+    
+    // But it should still have the original data
+    assert!(!file.data().is_empty());
+}
\ No newline at end of file
diff --git a/utils/src/lib.rs b/utils/src/lib.rs
index fb9eeb3..9fdf4ef 100644
--- a/utils/src/lib.rs
+++ b/utils/src/lib.rs
@@ -27,7 +27,7 @@ pub fn get_files<'t>(
         .filter(|e| e.file_type().is_file())
         .filter_map(move |e| {
             let rel_path = path_to_str(e.path().strip_prefix(folder_path).unwrap());
-            let rel_path = format!("{}{}", prefix, rel_path);
+            let rel_path = format!("{prefix}{rel_path}");
             let full_canonical_path =
                 path_to_str(std::fs::canonicalize(e.path()).expect("Could not get canonical path"));
 

From 209aecfd8bbd3f7bab6948f15876a6fd6a279a74 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 20 Jul 2025 08:04:14 +0000
Subject: [PATCH 4/9] Fix clippy warnings and add explicit test coverage for
 DynamicFile compression methods

Co-authored-by: SeriousBug <1008124+SeriousBug@users.noreply.github.com>
---
 tests/basic.rs       |  1 +
 tests/compression.rs |  6 +++---
 tests/dynamic.rs     | 20 ++++++++++++++++++++
 3 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/tests/basic.rs b/tests/basic.rs
index dab08bb..399607f 100644
--- a/tests/basic.rs
+++ b/tests/basic.rs
@@ -41,6 +41,7 @@ fn file_name_exists() {
 #[test]
 fn readme_example() {
     let index = Embed::get("index.html").unwrap().data();
+    #[allow(clippy::useless_asref)]
     let contents = std::str::from_utf8(index.as_ref()).unwrap();
     assert!(!contents.is_empty());
 }
diff --git a/tests/compression.rs b/tests/compression.rs
index 220b529..b837d65 100644
--- a/tests/compression.rs
+++ b/tests/compression.rs
@@ -29,7 +29,7 @@ fn compression_gzip_roundtrip() {
     let compressed = Embed::get("index.html").unwrap().data_gzip().unwrap();
     let mut decompressed: Vec<u8> = Vec::new();
     let mut decoder = GzDecoder::new(&mut decompressed);
-    decoder.write_all(&compressed[..]).unwrap();
+    decoder.write_all(compressed).unwrap();
     decoder.finish().unwrap();
     let decompressed_body = String::from_utf8_lossy(&decompressed[..]);
     assert!(decompressed_body.starts_with("<!DOCTYPE html>"));
@@ -39,7 +39,7 @@ fn compression_gzip_roundtrip() {
 fn compression_br_roundtrip() {
     let compressed = Embed::get("index.html").unwrap().data_br().unwrap();
     let mut decompressed: Vec<u8> = Vec::new();
-    let mut data_read = BufReader::new(&compressed[..]);
+    let mut data_read = BufReader::new(compressed);
     brotli::BrotliDecompress(&mut data_read, &mut decompressed).unwrap();
     let decompressed_body = String::from_utf8_lossy(&decompressed[..]);
     assert!(decompressed_body.starts_with("<!DOCTYPE html>"));
@@ -48,7 +48,7 @@ fn compression_br_roundtrip() {
 #[test]
 fn compression_zstd_roundtrip() {
     let compressed = Embed::get("index.html").unwrap().data_zstd().unwrap();
-    let decompressed = zstd::bulk::decompress(&compressed, 1024 * 1024).unwrap();
+    let decompressed = zstd::bulk::decompress(compressed, 1024 * 1024).unwrap();
     let decompressed_body = String::from_utf8_lossy(&decompressed[..]);
     assert!(decompressed_body.starts_with("<!DOCTYPE html>"));
 }
diff --git a/tests/dynamic.rs b/tests/dynamic.rs
index 3b1a200..6f275bf 100644
--- a/tests/dynamic.rs
+++ b/tests/dynamic.rs
@@ -32,4 +32,24 @@ fn dynamic_file_image_compressed_data_is_none() {
     
     // But it should still have the original data
     assert!(!file.data().is_empty());
+}
+
+#[test]
+fn explicit_dynamic_compression_coverage() {
+    // Explicitly test to ensure coverage of DynamicFile compression methods
+    let file = DynamicAssets::get("index.html").unwrap();
+    
+    // Test each compression method explicitly to ensure coverage
+    let gzip_result = file.data_gzip();
+    assert_eq!(gzip_result, None);
+    
+    let br_result = file.data_br(); 
+    assert_eq!(br_result, None);
+    
+    let zstd_result = file.data_zstd();
+    assert_eq!(zstd_result, None);
+    
+    // Ensure we have actual data though
+    let actual_data = file.data();
+    assert!(!actual_data.is_empty());
 }
\ No newline at end of file

From 2f7dbac6fe9c9de92224f1bf623d276fd1aedc4d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 20 Jul 2025 08:08:21 +0000
Subject: [PATCH 5/9] Fix dynamic tests to handle both always-embed and debug
 modes correctly

Co-authored-by: SeriousBug <1008124+SeriousBug@users.noreply.github.com>
---
 tests/dynamic.rs | 69 +++++++++++++++++++++++++++++++++++-------------
 1 file changed, 51 insertions(+), 18 deletions(-)

diff --git a/tests/dynamic.rs b/tests/dynamic.rs
index 6f275bf..d564f3e 100644
--- a/tests/dynamic.rs
+++ b/tests/dynamic.rs
@@ -11,12 +11,22 @@ fn dynamic_file_compressed_data_is_none() {
     // In debug mode without always-embed, this should use DynamicFile
     let file = DynamicAssets::get("index.html").unwrap();
     
-    // DynamicFile always returns None for compressed data
-    assert!(file.data_gzip().is_none());
-    assert!(file.data_br().is_none());
-    assert!(file.data_zstd().is_none());
+    // When always-embed is not enabled, DynamicFile always returns None for compressed data
+    #[cfg(not(feature = "always-embed"))]
+    {
+        assert!(file.data_gzip().is_none());
+        assert!(file.data_br().is_none());
+        assert!(file.data_zstd().is_none());
+    }
     
-    // But it should still have the original data
+    // When always-embed is enabled, EmbeddedFile may have compressed data
+    #[cfg(feature = "always-embed")]
+    {
+        // Just verify the file exists and has data - compression depends on the build
+        assert!(!file.data().is_empty());
+    }
+    
+    // But it should always have the original data
     assert!(!file.data().is_empty());
 }
 
@@ -25,12 +35,22 @@ fn dynamic_file_image_compressed_data_is_none() {
     // Test with an image file too
     let file = DynamicAssets::get("images/flower.jpg").unwrap();
     
-    // DynamicFile always returns None for compressed data
-    assert!(file.data_gzip().is_none());
-    assert!(file.data_br().is_none());
-    assert!(file.data_zstd().is_none());
+    // When always-embed is not enabled, DynamicFile always returns None for compressed data
+    #[cfg(not(feature = "always-embed"))]
+    {
+        assert!(file.data_gzip().is_none());
+        assert!(file.data_br().is_none());
+        assert!(file.data_zstd().is_none());
+    }
+    
+    // When always-embed is enabled, EmbeddedFile may have compressed data (usually None for images)
+    #[cfg(feature = "always-embed")]
+    {
+        // Just verify the file exists and has data
+        assert!(!file.data().is_empty());
+    }
     
-    // But it should still have the original data
+    // But it should always have the original data
     assert!(!file.data().is_empty());
 }
 
@@ -39,15 +59,28 @@ fn explicit_dynamic_compression_coverage() {
     // Explicitly test to ensure coverage of DynamicFile compression methods
     let file = DynamicAssets::get("index.html").unwrap();
     
-    // Test each compression method explicitly to ensure coverage
-    let gzip_result = file.data_gzip();
-    assert_eq!(gzip_result, None);
-    
-    let br_result = file.data_br(); 
-    assert_eq!(br_result, None);
+    // When always-embed is not enabled, test the DynamicFile paths
+    #[cfg(not(feature = "always-embed"))]
+    {
+        // Test each compression method explicitly to ensure coverage
+        let gzip_result = file.data_gzip();
+        assert_eq!(gzip_result, None);
+        
+        let br_result = file.data_br(); 
+        assert_eq!(br_result, None);
+        
+        let zstd_result = file.data_zstd();
+        assert_eq!(zstd_result, None);
+    }
     
-    let zstd_result = file.data_zstd();
-    assert_eq!(zstd_result, None);
+    // When always-embed is enabled, test the EmbeddedFile paths
+    #[cfg(feature = "always-embed")]
+    {
+        // Just verify the methods work - the actual compressed data depends on build configuration
+        let _gzip_result = file.data_gzip();
+        let _br_result = file.data_br(); 
+        let _zstd_result = file.data_zstd();
+    }
     
     // Ensure we have actual data though
     let actual_data = file.data();

From 50033204b7a56784398d38e8fe4fbc89078f8cb9 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 20 Jul 2025 08:28:18 +0000
Subject: [PATCH 6/9] Format code with cargo fmt

Co-authored-by: SeriousBug <1008124+SeriousBug@users.noreply.github.com>
---
 impl/src/compress.rs |  3 +--
 impl/src/lib.rs      |  5 ++++-
 tests/compression.rs |  5 ++++-
 tests/dynamic.rs     | 28 ++++++++++++++--------------
 tests/zstd.rs        |  2 +-
 5 files changed, 24 insertions(+), 19 deletions(-)

diff --git a/impl/src/compress.rs b/impl/src/compress.rs
index b20495c..53390fc 100644
--- a/impl/src/compress.rs
+++ b/impl/src/compress.rs
@@ -43,8 +43,7 @@ pub(crate) fn compress_br(data: &[u8]) -> Option<Vec<u8>> {
 
 pub(crate) fn compress_zstd(data: &[u8]) -> Option<Vec<u8>> {
     let mut data_zstd: Vec<u8> = Vec::new();
-    let mut encoder = ZstdEncoder::new(&mut data_zstd, 3)
-        .expect("Failed to create zstd encoder");
+    let mut encoder = ZstdEncoder::new(&mut data_zstd, 3).expect("Failed to create zstd encoder");
     encoder
         .write_all(data)
         .expect("Failed to compress zstd data");
diff --git a/impl/src/lib.rs b/impl/src/lib.rs
index 80cbcfb..8f38ff8 100644
--- a/impl/src/lib.rs
+++ b/impl/src/lib.rs
@@ -87,7 +87,10 @@ fn impl_rust_embed_for_web(ast: &syn::DeriveInput) -> TokenStream2 {
     }
 }
 
-#[proc_macro_derive(RustEmbed, attributes(folder, prefix, include, exclude, gzip, br, zstd))]
+#[proc_macro_derive(
+    RustEmbed,
+    attributes(folder, prefix, include, exclude, gzip, br, zstd)
+)]
 /// A folder that is embedded into your program.
 ///
 /// For example:
diff --git a/tests/compression.rs b/tests/compression.rs
index b837d65..baf17b0 100644
--- a/tests/compression.rs
+++ b/tests/compression.rs
@@ -21,7 +21,10 @@ fn image_files_are_not_compressed() {
         .data_gzip()
         .is_none());
     assert!(Embed::get("images/flower.jpg").unwrap().data_br().is_none());
-    assert!(Embed::get("images/flower.jpg").unwrap().data_zstd().is_none());
+    assert!(Embed::get("images/flower.jpg")
+        .unwrap()
+        .data_zstd()
+        .is_none());
 }
 
 #[test]
diff --git a/tests/dynamic.rs b/tests/dynamic.rs
index d564f3e..1ef6c57 100644
--- a/tests/dynamic.rs
+++ b/tests/dynamic.rs
@@ -10,7 +10,7 @@ struct DynamicAssets;
 fn dynamic_file_compressed_data_is_none() {
     // In debug mode without always-embed, this should use DynamicFile
     let file = DynamicAssets::get("index.html").unwrap();
-    
+
     // When always-embed is not enabled, DynamicFile always returns None for compressed data
     #[cfg(not(feature = "always-embed"))]
     {
@@ -18,14 +18,14 @@ fn dynamic_file_compressed_data_is_none() {
         assert!(file.data_br().is_none());
         assert!(file.data_zstd().is_none());
     }
-    
+
     // When always-embed is enabled, EmbeddedFile may have compressed data
     #[cfg(feature = "always-embed")]
     {
         // Just verify the file exists and has data - compression depends on the build
         assert!(!file.data().is_empty());
     }
-    
+
     // But it should always have the original data
     assert!(!file.data().is_empty());
 }
@@ -34,7 +34,7 @@ fn dynamic_file_compressed_data_is_none() {
 fn dynamic_file_image_compressed_data_is_none() {
     // Test with an image file too
     let file = DynamicAssets::get("images/flower.jpg").unwrap();
-    
+
     // When always-embed is not enabled, DynamicFile always returns None for compressed data
     #[cfg(not(feature = "always-embed"))]
     {
@@ -42,14 +42,14 @@ fn dynamic_file_image_compressed_data_is_none() {
         assert!(file.data_br().is_none());
         assert!(file.data_zstd().is_none());
     }
-    
+
     // When always-embed is enabled, EmbeddedFile may have compressed data (usually None for images)
     #[cfg(feature = "always-embed")]
     {
         // Just verify the file exists and has data
         assert!(!file.data().is_empty());
     }
-    
+
     // But it should always have the original data
     assert!(!file.data().is_empty());
 }
@@ -58,31 +58,31 @@ fn dynamic_file_image_compressed_data_is_none() {
 fn explicit_dynamic_compression_coverage() {
     // Explicitly test to ensure coverage of DynamicFile compression methods
     let file = DynamicAssets::get("index.html").unwrap();
-    
+
     // When always-embed is not enabled, test the DynamicFile paths
     #[cfg(not(feature = "always-embed"))]
     {
         // Test each compression method explicitly to ensure coverage
         let gzip_result = file.data_gzip();
         assert_eq!(gzip_result, None);
-        
-        let br_result = file.data_br(); 
+
+        let br_result = file.data_br();
         assert_eq!(br_result, None);
-        
+
         let zstd_result = file.data_zstd();
         assert_eq!(zstd_result, None);
     }
-    
+
     // When always-embed is enabled, test the EmbeddedFile paths
     #[cfg(feature = "always-embed")]
     {
         // Just verify the methods work - the actual compressed data depends on build configuration
         let _gzip_result = file.data_gzip();
-        let _br_result = file.data_br(); 
+        let _br_result = file.data_br();
         let _zstd_result = file.data_zstd();
     }
-    
+
     // Ensure we have actual data though
     let actual_data = file.data();
     assert!(!actual_data.is_empty());
-}
\ No newline at end of file
+}
diff --git a/tests/zstd.rs b/tests/zstd.rs
index 8784bc7..1ca2451 100644
--- a/tests/zstd.rs
+++ b/tests/zstd.rs
@@ -36,4 +36,4 @@ fn zstd_is_not_available_when_disabled() {
 fn image_files_dont_get_zstd_compressed() {
     let file = DefaultZstd::get("images/flower.jpg").unwrap();
     assert!(file.data_zstd().is_none());
-}
\ No newline at end of file
+}

From 85eb17c5c2a9b36e4b6d1995da7c2a84a64fb328 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 20 Jul 2025 08:37:55 +0000
Subject: [PATCH 7/9] Make zstd compression an optional feature

Co-authored-by: SeriousBug <1008124+SeriousBug@users.noreply.github.com>
---
 Cargo.toml                |  7 ++++---
 impl/Cargo.toml           |  3 ++-
 impl/src/compress.rs      |  7 +++++++
 tests/dynamic.rs          | 16 +++++++++++++++
 tests/feature_zstd.rs     | 43 +++++++++++++++++++++++++++++++++++++++
 utils/Cargo.toml          |  1 +
 utils/src/config.rs       | 12 ++++++++++-
 utils/src/file/common.rs  |  9 ++++++++
 utils/src/file/dynamic.rs |  1 +
 utils/src/file/embed.rs   | 36 ++++++++++++++++++++++++++++++++
 10 files changed, 130 insertions(+), 5 deletions(-)
 create mode 100644 tests/feature_zstd.rs

diff --git a/Cargo.toml b/Cargo.toml
index 9cf4257..6f6b20d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,7 +23,7 @@ zstd = "0.13"
 actix-web = "4.4"
 
 [features]
-default = ["interpolate-folder-path", "include-exclude"]
+default = ["interpolate-folder-path", "include-exclude", "compression-zstd"]
 # Even in debug mode use a release embed.
 # We use this to test embed code in our tests.
 always-embed = ["rust-embed-for-web-impl/always-embed"]
@@ -33,6 +33,7 @@ include-exclude = [
   "rust-embed-for-web-impl/include-exclude",
   "rust-embed-for-web-utils/include-exclude",
 ]
+compression-zstd = ["rust-embed-for-web-impl/compression-zstd", "rust-embed-for-web-utils/compression-zstd"]
 
 [workspace]
 members = ["impl", "utils"]
@@ -40,7 +41,7 @@ members = ["impl", "utils"]
 [[test]]
 name = "compression"
 path = "tests/compression.rs"
-required-features = ["always-embed"]
+required-features = ["always-embed", "compression-zstd"]
 
 [[test]]
 name = "gzip"
@@ -50,7 +51,7 @@ required-features = ["always-embed"]
 [[test]]
 name = "zstd"
 path = "tests/zstd.rs"
-required-features = ["always-embed"]
+required-features = ["always-embed", "compression-zstd"]
 
 [[test]]
 name = "include-exclude"
diff --git a/impl/Cargo.toml b/impl/Cargo.toml
index a598e05..e86b644 100644
--- a/impl/Cargo.toml
+++ b/impl/Cargo.toml
@@ -27,7 +27,7 @@ walkdir = "2.4.0"
 # Compression
 flate2 = "1.0"
 brotli = "6.0"
-zstd = "0.13"
+zstd = { version = "0.13", optional = true }
 
 globset = { version = "0.4", optional = true }
 
@@ -40,3 +40,4 @@ default = []
 interpolate-folder-path = ["shellexpand"]
 include-exclude = ["rust-embed-for-web-utils/include-exclude", "globset"]
 always-embed = []
+compression-zstd = ["zstd", "rust-embed-for-web-utils/compression-zstd"]
diff --git a/impl/src/compress.rs b/impl/src/compress.rs
index 53390fc..9ced6e8 100644
--- a/impl/src/compress.rs
+++ b/impl/src/compress.rs
@@ -2,6 +2,7 @@ use std::io::{BufReader, Write};
 
 use brotli::enc::BrotliEncoderParams;
 use flate2::{write::GzEncoder, Compression};
+#[cfg(feature = "compression-zstd")]
 use zstd::stream::write::Encoder as ZstdEncoder;
 
 /// Only include the compressed version if it is at least this much smaller than
@@ -41,6 +42,7 @@ pub(crate) fn compress_br(data: &[u8]) -> Option<Vec<u8>> {
     }
 }
 
+#[cfg(feature = "compression-zstd")]
 pub(crate) fn compress_zstd(data: &[u8]) -> Option<Vec<u8>> {
     let mut data_zstd: Vec<u8> = Vec::new();
     let mut encoder = ZstdEncoder::new(&mut data_zstd, 3).expect("Failed to create zstd encoder");
@@ -57,3 +59,8 @@ pub(crate) fn compress_zstd(data: &[u8]) -> Option<Vec<u8>> {
         None
     }
 }
+
+#[cfg(not(feature = "compression-zstd"))]
+pub(crate) fn compress_zstd(_data: &[u8]) -> Option<Vec<u8>> {
+    None
+}
diff --git a/tests/dynamic.rs b/tests/dynamic.rs
index 1ef6c57..f8dcef2 100644
--- a/tests/dynamic.rs
+++ b/tests/dynamic.rs
@@ -86,3 +86,19 @@ fn explicit_dynamic_compression_coverage() {
     let actual_data = file.data();
     assert!(!actual_data.is_empty());
 }
+
+#[test]
+fn specific_dynamic_none_coverage() {
+    // Create a DynamicFile directly to ensure we test the None paths
+    use rust_embed_for_web::{DynamicFile, EmbedableFile};
+
+    let file = DynamicFile::read_from_fs("examples/public/index.html").unwrap();
+
+    // These should all return None for DynamicFile, ensuring coverage of those lines
+    assert!(file.data_gzip().is_none());
+    assert!(file.data_br().is_none());
+    assert!(file.data_zstd().is_none());
+
+    // But the regular data should work
+    assert!(!file.data().is_empty());
+}
diff --git a/tests/feature_zstd.rs b/tests/feature_zstd.rs
new file mode 100644
index 0000000..e3f415c
--- /dev/null
+++ b/tests/feature_zstd.rs
@@ -0,0 +1,43 @@
+use rust_embed_for_web::{EmbedableFile, RustEmbed};
+
+#[derive(RustEmbed)]
+#[folder = "examples/public/"]
+struct Assets;
+
+#[test]
+fn zstd_feature_behavior() {
+    let file = Assets::get("index.html").unwrap();
+
+    // Test that zstd behavior matches feature flag
+    #[cfg(feature = "compression-zstd")]
+    {
+        // When feature is enabled, data_zstd might return Some or None
+        // depending on build configuration and compression effectiveness
+        let zstd_data = file.data_zstd();
+        // Just verify that the method exists and doesn't panic
+        match zstd_data {
+            Some(_) => {
+                // Zstd compression was effective
+            }
+            None => {
+                // Zstd compression was not effective or disabled for this file
+            }
+        }
+    }
+
+    #[cfg(not(feature = "compression-zstd"))]
+    {
+        // When feature is disabled, data_zstd should always return None
+        assert!(file.data_zstd().is_none());
+    }
+}
+
+#[test]
+fn zstd_default_trait_implementation() {
+    use rust_embed_for_web::{DynamicFile, EmbedableFile};
+
+    let file = DynamicFile::read_from_fs("examples/public/index.html").unwrap();
+
+    // For DynamicFile, data_zstd should always return None regardless of feature
+    assert!(file.data_zstd().is_none());
+}
diff --git a/utils/Cargo.toml b/utils/Cargo.toml
index 6e3bf9f..540b4be 100644
--- a/utils/Cargo.toml
+++ b/utils/Cargo.toml
@@ -26,3 +26,4 @@ globset = { version = "0.4", optional = true }
 [features]
 default = []
 include-exclude = ["globset"]
+compression-zstd = []
diff --git a/utils/src/config.rs b/utils/src/config.rs
index bc74f77..559bdf3 100644
--- a/utils/src/config.rs
+++ b/utils/src/config.rs
@@ -21,7 +21,10 @@ impl Default for Config {
             exclude: vec![],
             gzip: true,
             br: true,
+            #[cfg(feature = "compression-zstd")]
             zstd: true,
+            #[cfg(not(feature = "compression-zstd"))]
+            zstd: false,
         }
     }
 }
@@ -107,6 +110,13 @@ impl Config {
     }
 
     pub fn should_zstd(&self) -> bool {
-        self.zstd
+        #[cfg(feature = "compression-zstd")]
+        {
+            self.zstd
+        }
+        #[cfg(not(feature = "compression-zstd"))]
+        {
+            false
+        }
     }
 }
diff --git a/utils/src/file/common.rs b/utils/src/file/common.rs
index f7b4684..e7862e0 100644
--- a/utils/src/file/common.rs
+++ b/utils/src/file/common.rs
@@ -42,7 +42,16 @@ pub trait EmbedableFile {
     /// This is `Some` if precompression has been done. `None` if the file was
     /// not precompressed, either because the file doesn't benefit from
     /// compression or because zstd was disabled with `#[zstd = false]`.
+    #[cfg(feature = "compression-zstd")]
     fn data_zstd(&self) -> Option<Self::Data>;
+
+    /// The contents of the file, compressed with zstd.
+    ///
+    /// Always returns `None` when the compression-zstd feature is disabled.
+    #[cfg(not(feature = "compression-zstd"))]
+    fn data_zstd(&self) -> Option<Self::Data> {
+        None
+    }
     /// The UNIX timestamp of when the file was last modified.
     fn last_modified_timestamp(&self) -> Option<i64>;
     /// The rfc2822 encoded last modified date. This is the format you use for
diff --git a/utils/src/file/dynamic.rs b/utils/src/file/dynamic.rs
index a541311..631e22c 100644
--- a/utils/src/file/dynamic.rs
+++ b/utils/src/file/dynamic.rs
@@ -48,6 +48,7 @@ impl EmbedableFile for DynamicFile {
         None
     }
 
+    #[cfg(feature = "compression-zstd")]
     fn data_zstd(&self) -> Option<Self::Data> {
         None
     }
diff --git a/utils/src/file/embed.rs b/utils/src/file/embed.rs
index 14b5275..eff7d43 100644
--- a/utils/src/file/embed.rs
+++ b/utils/src/file/embed.rs
@@ -15,6 +15,7 @@ pub struct EmbeddedFile {
     data: &'static [u8],
     data_gzip: Option<&'static [u8]>,
     data_br: Option<&'static [u8]>,
+    #[cfg(feature = "compression-zstd")]
     data_zstd: Option<&'static [u8]>,
     hash: &'static str,
     etag: &'static str,
@@ -43,6 +44,7 @@ impl EmbedableFile for EmbeddedFile {
         self.data_br
     }
 
+    #[cfg(feature = "compression-zstd")]
     fn data_zstd(&self) -> Option<Self::Data> {
         self.data_zstd
     }
@@ -73,6 +75,7 @@ impl EmbeddedFile {
     #[allow(clippy::too_many_arguments)]
     /// This is used internally in derived code to create embedded file objects.
     /// You don't want to manually use this function!
+    #[cfg(feature = "compression-zstd")]
     pub fn __internal_make(
         // Make sure that the order of these parameters is correct in respect to
         // the file contents! And if you are changing or reordering any of
@@ -101,6 +104,39 @@ impl EmbeddedFile {
             mime_type,
         }
     }
+
+    #[doc(hidden)]
+    #[allow(clippy::too_many_arguments)]
+    /// This is used internally in derived code to create embedded file objects.
+    /// You don't want to manually use this function!
+    #[cfg(not(feature = "compression-zstd"))]
+    pub fn __internal_make(
+        // Make sure that the order of these parameters is correct in respect to
+        // the file contents! And if you are changing or reordering any of
+        // these, make sure to update the corresponding call in `impl`
+        name: &'static str,
+        data: &'static [u8],
+        data_gzip: Option<&'static [u8]>,
+        data_br: Option<&'static [u8]>,
+        _data_zstd: Option<&'static [u8]>, // Ignored when feature disabled
+        hash: &'static str,
+        etag: &'static str,
+        last_modified: Option<&'static str>,
+        last_modified_timestamp: Option<i64>,
+        mime_type: Option<&'static str>,
+    ) -> EmbeddedFile {
+        EmbeddedFile {
+            name,
+            data,
+            data_gzip,
+            data_br,
+            hash,
+            etag,
+            last_modified,
+            last_modified_timestamp,
+            mime_type,
+        }
+    }
 }
 
 impl Debug for EmbeddedFile {

From 5e5bb44ba03c428da5f89415ed3c5c5c4eb97e95 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 20 Jul 2025 08:42:31 +0000
Subject: [PATCH 8/9] Add comprehensive tests for optional zstd feature

Co-authored-by: SeriousBug <1008124+SeriousBug@users.noreply.github.com>
---
 Cargo.toml                        |  5 +++
 tests/compression_without_zstd.rs | 64 +++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+)
 create mode 100644 tests/compression_without_zstd.rs

diff --git a/Cargo.toml b/Cargo.toml
index 6f6b20d..9d496d8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,6 +43,11 @@ name = "compression"
 path = "tests/compression.rs"
 required-features = ["always-embed", "compression-zstd"]
 
+[[test]]
+name = "compression_without_zstd"
+path = "tests/compression_without_zstd.rs"
+required-features = ["always-embed"]
+
 [[test]]
 name = "gzip"
 path = "tests/gzip.rs"
diff --git a/tests/compression_without_zstd.rs b/tests/compression_without_zstd.rs
new file mode 100644
index 0000000..51fdd31
--- /dev/null
+++ b/tests/compression_without_zstd.rs
@@ -0,0 +1,64 @@
+use std::io::{BufReader, Write};
+
+use flate2::write::GzDecoder;
+use rust_embed_for_web::{EmbedableFile, RustEmbed};
+
+#[derive(RustEmbed)]
+#[folder = "examples/public"]
+struct Embed;
+
+#[test]
+fn html_files_gzip_and_br_compression() {
+    assert!(Embed::get("index.html").unwrap().data_gzip().is_some());
+    assert!(Embed::get("index.html").unwrap().data_br().is_some());
+}
+
+#[test]
+fn zstd_behavior_without_feature() {
+    // When compression-zstd feature is not enabled, data_zstd should return None
+    #[cfg(not(feature = "compression-zstd"))]
+    {
+        assert!(Embed::get("index.html").unwrap().data_zstd().is_none());
+    }
+
+    // When compression-zstd feature is enabled, it may return Some or None based on effectiveness
+    #[cfg(feature = "compression-zstd")]
+    {
+        // Just test that the method doesn't panic
+        let _ = Embed::get("index.html").unwrap().data_zstd();
+    }
+}
+
+#[test]
+fn image_files_are_not_compressed() {
+    assert!(Embed::get("images/flower.jpg")
+        .unwrap()
+        .data_gzip()
+        .is_none());
+    assert!(Embed::get("images/flower.jpg").unwrap().data_br().is_none());
+    assert!(Embed::get("images/flower.jpg")
+        .unwrap()
+        .data_zstd()
+        .is_none());
+}
+
+#[test]
+fn compression_gzip_roundtrip() {
+    let compressed = Embed::get("index.html").unwrap().data_gzip().unwrap();
+    let mut decompressed: Vec<u8> = Vec::new();
+    let mut decoder = GzDecoder::new(&mut decompressed);
+    decoder.write_all(compressed).unwrap();
+    decoder.finish().unwrap();
+    let decompressed_body = String::from_utf8_lossy(&decompressed[..]);
+    assert!(decompressed_body.starts_with("<!DOCTYPE html>"));
+}
+
+#[test]
+fn compression_br_roundtrip() {
+    let compressed = Embed::get("index.html").unwrap().data_br().unwrap();
+    let mut decompressed: Vec<u8> = Vec::new();
+    let mut data_read = BufReader::new(compressed);
+    brotli::BrotliDecompress(&mut data_read, &mut decompressed).unwrap();
+    let decompressed_body = String::from_utf8_lossy(&decompressed[..]);
+    assert!(decompressed_body.starts_with("<!DOCTYPE html>"));
+}

From 547842820c360c32d5a78c9350d27d8329658987 Mon Sep 17 00:00:00 2001
From: Kaan Barmore-Genc <kaan@bgenc.dev>
Date: Fri, 7 Nov 2025 17:43:34 -0600
Subject: [PATCH 9/9] Make compression-zstd opt-in and add documentation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Changes:
- Remove compression-zstd from default features (requires C bindings)
- Add comprehensive documentation for zstd compression feature
- Document compression functions and config methods
- Reorganize README features section for clarity

The zstd feature is now opt-in due to its C library dependency,
which may not be compatible with all build environments.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 Cargo.toml           |  2 +-
 README.md            | 29 +++++++++++++++++++++++++----
 impl/src/compress.rs |  5 +++++
 utils/src/config.rs  |  5 +++++
 4 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 9d496d8..54e2d80 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,7 +23,7 @@ zstd = "0.13"
 actix-web = "4.4"
 
 [features]
-default = ["interpolate-folder-path", "include-exclude", "compression-zstd"]
+default = ["interpolate-folder-path", "include-exclude"]
 # Even in debug mode use a release embed.
 # We use this to test embed code in our tests.
 always-embed = ["rust-embed-for-web-impl/always-embed"]
diff --git a/README.md b/README.md
index 7223d21..09fcba1 100644
--- a/README.md
+++ b/README.md
@@ -76,9 +76,11 @@ archives already don't include their compressed versions. However you can
 
 ## Features
 
-Both of the following features are enabled by default.
+### Default Features
 
-### `interpolate-folder-path`
+The following features are enabled by default.
+
+#### `interpolate-folder-path`
 
 Allow environment variables and `~`s to be used in the `folder` path. Example:
 
@@ -91,7 +93,7 @@ struct Asset;
 `~` will expand into your home folder, and `${PROJECT_NAME}` will expand into
 the value of the `PROJECT_NAME` environment variable.
 
-### `include-exclude`
+#### `include-exclude`
 
 You can filter which files are embedded by adding one or more `#[include = "*.txt"]` and `#[exclude = "*.jpg"]` attributes.
 Matching is done on relative file paths --the paths you use for the `.get` call-- via [`globset`](https://docs.rs/globset/latest/globset/).
@@ -111,7 +113,26 @@ For example, if you wanted to exclude all `.svg` files except for one named
 struct Assets;
 ```
 
-### `prefix`
+### Optional Features
+
+#### `compression-zstd`
+
+Enables zstd compression support for embedded files. When enabled, files will be compressed with zstd (in addition to gzip and brotli), allowing you to serve zstd-compressed content to clients that support it.
+
+**Note:** This feature is **not enabled by default** because the `zstd` crate uses C bindings, which may not be compatible with all build environments.
+
+To enable zstd compression, add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+rust-embed-for-web = { version = "11.2.1", features = ["compression-zstd"] }
+```
+
+You can also disable zstd compression for specific embeds using the `#[zstd = false]` attribute as described in the "Disabling compression" section above.
+
+### Other Configuration
+
+#### `prefix`
 
 You can specify a prefix, which will be added to the path of the files. For example:
 
diff --git a/impl/src/compress.rs b/impl/src/compress.rs
index 9ced6e8..445241e 100644
--- a/impl/src/compress.rs
+++ b/impl/src/compress.rs
@@ -42,9 +42,14 @@ pub(crate) fn compress_br(data: &[u8]) -> Option<Vec<u8>> {
     }
 }
 
+/// Compresses data using zstd compression.
+///
+/// Returns the compressed data if it's smaller than the threshold, `None` otherwise.
+/// Uses compression level 3 as a balance between compression ratio and speed.
 #[cfg(feature = "compression-zstd")]
 pub(crate) fn compress_zstd(data: &[u8]) -> Option<Vec<u8>> {
     let mut data_zstd: Vec<u8> = Vec::new();
+    // Level 3 provides good compression with reasonable speed for build-time compression
     let mut encoder = ZstdEncoder::new(&mut data_zstd, 3).expect("Failed to create zstd encoder");
     encoder
         .write_all(data)
diff --git a/utils/src/config.rs b/utils/src/config.rs
index 559bdf3..524bbd4 100644
--- a/utils/src/config.rs
+++ b/utils/src/config.rs
@@ -61,6 +61,7 @@ impl Config {
         self.br = status;
     }
 
+    /// Enable or disable zstd compression for embedded files.
     pub fn set_zstd(&mut self, status: bool) {
         self.zstd = status;
     }
@@ -109,6 +110,10 @@ impl Config {
         self.br
     }
 
+    /// Check if zstd compression should be used for embedded files.
+    ///
+    /// Returns `false` when the compression-zstd feature is not enabled,
+    /// even if the config value is set to `true`.
     pub fn should_zstd(&self) -> bool {
         #[cfg(feature = "compression-zstd")]
         {