From b644dc588bb102023da4b1fc25b90761a450c431 Mon Sep 17 00:00:00 2001
From: bigsaltyfishes <bigsaltyfishes@gmail.com>
Date: Sat, 7 Jun 2025 16:14:41 +0800
Subject: [PATCH 1/8] feat: Add Gzip compress support for wasm binary

* Add data-gzip-compression attribute.
* Enable compression by default on release build.
* Use DecompressionStream API to decompress at runtime.

Signed-off-by: bigsaltyfishes <bigsaltyfishes@gmail.com>
---
 src/pipelines/rust/gzip.rs   | 55 ++++++++++++++++++++++++
 src/pipelines/rust/mod.rs    | 83 +++++++++++++++++++++++++++++++++++-
 src/pipelines/rust/output.rs | 38 ++++++++++++++---
 3 files changed, 168 insertions(+), 8 deletions(-)
 create mode 100644 src/pipelines/rust/gzip.rs

diff --git a/src/pipelines/rust/gzip.rs b/src/pipelines/rust/gzip.rs
new file mode 100644
index 00000000..c687c216
--- /dev/null
+++ b/src/pipelines/rust/gzip.rs
@@ -0,0 +1,55 @@
+use std::{ops::Deref, str::FromStr};
+
+use anyhow::bail;
+use flate2::Compression;
+
+#[derive(PartialEq, Eq)]
+pub struct GzipLevel(Compression);
+
+impl GzipLevel {
+    pub const OFF: Self = Self(Compression::new(0));
+}
+
+impl FromStr for GzipLevel {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<Self, Self::Err> {
+        let level = match s {
+            "0" => Compression::new(0),
+            "1" => Compression::new(1),
+            "2" => Compression::new(2),
+            "3" => Compression::new(3),
+            "4" => Compression::new(4),
+            "5" => Compression::new(5),
+            "6" => Compression::new(6),
+            "7" => Compression::new(7),
+            "8" => Compression::new(8),
+            "9" => Compression::new(9),
+            "default" => Compression::default(),
+            "fast" => Compression::fast(),
+            "best" => Compression::best(),
+            _ => bail!("unknown gzip level `{}`", s),
+        };
+        Ok(Self(level))
+    }
+}
+
+impl AsRef<Compression> for GzipLevel {
+    fn as_ref(&self) -> &Compression {
+        &self.0
+    }
+}
+
+impl Deref for GzipLevel {
+    type Target = Compression;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Default for GzipLevel {
+    fn default() -> Self {
+        Self(Compression::default())
+    }
+}
diff --git a/src/pipelines/rust/mod.rs b/src/pipelines/rust/mod.rs
index 7a631608..90d59b29 100644
--- a/src/pipelines/rust/mod.rs
+++ b/src/pipelines/rust/mod.rs
@@ -1,5 +1,6 @@
 //! Rust application pipeline.
 
+mod gzip;
 mod output;
 mod sri;
 mod wasm_bindgen;
@@ -18,12 +19,16 @@ use crate::{
         types::CrossOrigin,
         CargoMetadata,
     },
-    pipelines::rust::sri::{SriBuilder, SriOptions, SriType},
+    pipelines::rust::{
+        gzip::GzipLevel,
+        sri::{SriBuilder, SriOptions, SriType},
+    },
     processing::{integrity::IntegrityType, minify::minify_js},
     tools::{self, Application, ToolInformation},
 };
 use anyhow::{anyhow, bail, ensure, Context, Result};
 use cargo_metadata::{Artifact, TargetKind};
+use flate2::bufread::GzEncoder;
 use minify_js::TopLevelMode;
 use seahash::SeaHasher;
 use std::{
@@ -97,6 +102,8 @@ pub struct RustApp {
     import_bindings_name: Option<String>,
     /// The name of the initializer module
     initializer: Option<PathBuf>,
+    /// Gzip compression level for the WASM file. Defaults to `GzipLevel::Default` on release build.
+    gzip_compression: GzipLevel,
 }
 
 /// Describes how the rust application is used.
@@ -185,6 +192,17 @@ impl RustApp {
                 RustAppType::Main => WasmBindgenTarget::Web,
                 RustAppType::Worker => WasmBindgenTarget::NoModules,
             });
+        let gzip_compression = attrs
+            .get("data-gzip-compression")
+            .map(|attr| attr.parse())
+            .transpose()?
+            .unwrap_or_else(|| {
+                if cfg.release {
+                    Default::default()
+                } else {
+                    GzipLevel::OFF
+                }
+            });
         let cross_origin = attrs
             .get("data-cross-origin")
             .map(|attr| CrossOrigin::from_str(attr))
@@ -307,6 +325,7 @@ impl RustApp {
             import_bindings_name,
             initializer,
             target_path,
+            gzip_compression
         })
     }
 
@@ -357,6 +376,7 @@ impl RustApp {
             import_bindings_name: None,
             initializer: None,
             target_path: None,
+            gzip_compression: GzipLevel::OFF,
         }))
     }
 
@@ -386,6 +406,11 @@ impl RustApp {
             .await
             .context("running wasm-opt")?;
 
+        // (optionally) gzip the wasm file
+        self.gzip_compression(&output.wasm_output)
+            .await
+            .context("gzip compression")?;
+
         // evaluate wasm integrity after all processing
         self.final_digest(&mut output)
             .await
@@ -761,6 +786,7 @@ impl RustApp {
             import_bindings: self.import_bindings,
             import_bindings_name: self.import_bindings_name.clone(),
             initializer,
+            gzip_compression_enabled: self.gzip_compression != GzipLevel::OFF,
             wasm_bindgen_features,
         })
     }
@@ -954,6 +980,61 @@ impl RustApp {
         Ok(())
     }
 
+    #[tracing::instrument(level = "trace", skip(self))]
+    async fn gzip_compression(&self, wasm_name: &str) -> Result<()> {
+        if !self.cfg.release {
+            return Ok(());
+        }
+
+        if self.gzip_compression == GzipLevel::OFF {
+            log::debug!("gzip compression is turned off");
+            return Ok(());
+        }
+
+        let gzip_name = "wasm-gzip";
+        let mode_segment = if self.cfg.release { "release" } else { "debug" };
+        let output = self
+            .manifest
+            .metadata
+            .target_directory
+            .join(gzip_name)
+            .join(mode_segment);
+        fs::create_dir_all(&output)
+            .await
+            .context("error creating wasm gzip compression output dir")?;
+
+        tracing::debug!("compressing with gzip level {}", self.gzip_compression.level());
+        let output = output.join(format!("{}_bg.wasm", self.name));
+        let target_wasm = self
+            .cfg
+            .staging_dist
+            .join(wasm_name)
+            .to_string_lossy()
+            .to_string();
+
+        let target_wasm_file = std::fs::File::open(&target_wasm)
+            .context("error opening wasm file for gzip compression")?;
+        let target_wasm_reader = std::io::BufReader::new(target_wasm_file);
+        let mut encoder = GzEncoder::new(
+            target_wasm_reader,
+            *self.gzip_compression,
+        );
+
+        let output_file = std::fs::File::create(&output)
+            .context("error creating gzip output file")?;
+        let mut output_writer = std::io::BufWriter::new(output_file);
+        std::io::copy(&mut encoder, &mut output_writer)
+            .context("error writing gzip compressed wasm file")?;
+
+        // Copy the generated WASM file to the dist dir.
+        tracing::debug!("copying generated wasm-opt artifact from '{output}' to '{target_wasm}'");
+        fs::copy(output, &target_wasm)
+            .await
+            .context("error copying (gzip compressed) wasm file to dist dir")?;
+
+        Ok(())
+    }
+
     /// Build the final WASM digest
     #[tracing::instrument(level = "trace", skip(self, output))]
     async fn final_digest(&self, output: &mut RustAppOutput) -> Result<()> {
diff --git a/src/pipelines/rust/output.rs b/src/pipelines/rust/output.rs
index 66e926e1..2ffbeca2 100644
--- a/src/pipelines/rust/output.rs
+++ b/src/pipelines/rust/output.rs
@@ -29,6 +29,8 @@ pub struct RustAppOutput {
     pub import_bindings: bool,
     /// The name of the WASM bindings import
     pub import_bindings_name: Option<String>,
+    /// Gzip compression enabled for the WASM file
+    pub gzip_compression_enabled: bool,
     /// The target of the initializer module
     pub initializer: Option<String>,
     /// The features supported by the version of wasm-bindgen used
@@ -141,21 +143,43 @@ dispatchEvent(new CustomEvent("TrunkApplicationStarted", {detail: {wasm}}));
         let init_with_object = self.wasm_bindgen_features.init_with_object;
 
         match &self.initializer {
-            None => format!(
-                r#"
+            None => {
+                if self.gzip_compression_enabled {
+                    format!(
+                        r#"
 <script type="module"{nonce}>
 import init{import} from '{base}{js}';
-const wasm = await init({init_arg});
+const resp = await fetch('{base}{wasm}');
+if (!resp.ok) {{
+    throw new Error('Failed to fetch WASM module: ' + resp.statusText);
+}}
+
+const decompressStream = resp.body.pipeThrough(new DecompressionStream('gzip'));
+const wasmBytes = await new Response(decompressStream).arrayBuffer();
+const wasm = await init({{ module_or_path: wasmBytes }});
 
 {bind}
 {fire}
 </script>"#,
-                init_arg = if init_with_object {
-                    format!("{{ module_or_path: '{base}{wasm}' }}")
+                    )
                 } else {
-                    format!("'{base}{wasm}'")
+                    format!(
+                        r#"
+<script type="module"{nonce}>
+import init{import} from '{base}{js}';
+const wasm = await init({init_arg});
+
+{bind}
+{fire}
+</script>"#,
+                        init_arg = if init_with_object {
+                            format!("{{ module_or_path: '{base}{wasm}' }}")
+                        } else {
+                            format!("'{base}{wasm}'")
+                        }
+                    )
                 }
-            ),
+            }
             Some(initializer) => format!(
                 r#"
 <script type="module"{nonce}>

From d7567b5f354b7727fbb380d1bce532d448078b92 Mon Sep 17 00:00:00 2001
From: bigsaltyfishes <bigsaltyfishes@gmail.com>
Date: Sat, 7 Jun 2025 17:45:56 +0800
Subject: [PATCH 2/8] feat: Extends compression supports

* Remove `data-gzip-compression` attribute.
* Add `data-compression-algorithm` and `data-compression-level` attributes.
* Add support for zlib(deflate) and deflate(deflate-raw) algorithm.

Signed-off-by: bigsaltyfishes <bigsaltyfishes@gmail.com>
---
 src/pipelines/rust/compress.rs | 107 +++++++++++++++++++++++++++++++++
 src/pipelines/rust/gzip.rs     |  55 -----------------
 src/pipelines/rust/mod.rs      |  73 +++++++++++++---------
 src/pipelines/rust/output.rs   |   8 +--
 4 files changed, 155 insertions(+), 88 deletions(-)
 create mode 100644 src/pipelines/rust/compress.rs
 delete mode 100644 src/pipelines/rust/gzip.rs

diff --git a/src/pipelines/rust/compress.rs b/src/pipelines/rust/compress.rs
new file mode 100644
index 00000000..c966f900
--- /dev/null
+++ b/src/pipelines/rust/compress.rs
@@ -0,0 +1,107 @@
+use std::{
+    io::{BufRead, Read},
+    ops::Deref,
+    str::FromStr,
+};
+
+use anyhow::bail;
+use flate2::{
+    bufread::{DeflateEncoder, GzEncoder, ZlibEncoder},
+    Compression,
+};
+
+#[derive(PartialEq, Eq, Debug, Default)]
+pub enum CompressionAlgorithm {
+    #[default]
+    Gzip,
+    Zlib,
+    Deflate,
+}
+
+impl CompressionAlgorithm {
+    pub fn encoder<'a, R: BufRead + Send + 'a>(
+        &self,
+        reader: R,
+        level: Compression,
+    ) -> Box<dyn Read + Send + 'a> {
+        match self {
+            Self::Gzip => Box::new(GzEncoder::new(reader, level)),
+            Self::Zlib => Box::new(ZlibEncoder::new(reader, level)),
+            Self::Deflate => Box::new(DeflateEncoder::new(reader, level)),
+        }
+    }
+}
+
+impl FromStr for CompressionAlgorithm {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "gzip" => Ok(Self::Gzip),
+            "deflate" => Ok(Self::Zlib),
+            "deflate-raw" => Ok(Self::Deflate),
+            _ => bail!("unknown compression algorithm `{}`", s),
+        }
+    }
+}
+
+impl ToString for CompressionAlgorithm {
+    fn to_string(&self) -> String {
+        match self {
+            Self::Gzip => "gzip".to_string(),
+            Self::Zlib => "deflate".to_string(),
+            Self::Deflate => "deflate-raw".to_string(),
+        }
+    }
+}
+
+#[derive(PartialEq, Eq)]
+pub struct CompressionLevel(Compression);
+
+impl CompressionLevel {
+    pub const OFF: Self = Self(Compression::new(0));
+}
+
+impl FromStr for CompressionLevel {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<Self, Self::Err> {
+        let level = match s {
+            "0" => Compression::new(0),
+            "1" => Compression::new(1),
+            "2" => Compression::new(2),
+            "3" => Compression::new(3),
+            "4" => Compression::new(4),
+            "5" => Compression::new(5),
+            "6" => Compression::new(6),
+            "7" => Compression::new(7),
+            "8" => Compression::new(8),
+            "9" => Compression::new(9),
+            "default" => Compression::default(),
+            "fast" => Compression::fast(),
+            "best" => Compression::best(),
+            _ => bail!("unknown gzip level `{}`", s),
+        };
+        Ok(Self(level))
+    }
+}
+
+impl AsRef<Compression> for CompressionLevel {
+    fn as_ref(&self) -> &Compression {
+        &self.0
+    }
+}
+
+impl Deref for CompressionLevel {
+    type Target = Compression;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Default for CompressionLevel {
+    fn default() -> Self {
+        Self(Compression::default())
+    }
+}
diff --git a/src/pipelines/rust/gzip.rs b/src/pipelines/rust/gzip.rs
deleted file mode 100644
index c687c216..00000000
--- a/src/pipelines/rust/gzip.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use std::{ops::Deref, str::FromStr};
-
-use anyhow::bail;
-use flate2::Compression;
-
-#[derive(PartialEq, Eq)]
-pub struct GzipLevel(Compression);
-
-impl GzipLevel {
-    pub const OFF: Self = Self(Compression::new(0));
-}
-
-impl FromStr for GzipLevel {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> anyhow::Result<Self, Self::Err> {
-        let level = match s {
-            "0" => Compression::new(0),
-            "1" => Compression::new(1),
-            "2" => Compression::new(2),
-            "3" => Compression::new(3),
-            "4" => Compression::new(4),
-            "5" => Compression::new(5),
-            "6" => Compression::new(6),
-            "7" => Compression::new(7),
-            "8" => Compression::new(8),
-            "9" => Compression::new(9),
-            "default" => Compression::default(),
-            "fast" => Compression::fast(),
-            "best" => Compression::best(),
-            _ => bail!("unknown gzip level `{}`", s),
-        };
-        Ok(Self(level))
-    }
-}
-
-impl AsRef<Compression> for GzipLevel {
-    fn as_ref(&self) -> &Compression {
-        &self.0
-    }
-}
-
-impl Deref for GzipLevel {
-    type Target = Compression;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl Default for GzipLevel {
-    fn default() -> Self {
-        Self(Compression::default())
-    }
-}
diff --git a/src/pipelines/rust/mod.rs b/src/pipelines/rust/mod.rs
index 90d59b29..5934ad25 100644
--- a/src/pipelines/rust/mod.rs
+++ b/src/pipelines/rust/mod.rs
@@ -1,6 +1,6 @@
 //! Rust application pipeline.
 
-mod gzip;
+mod compress;
 mod output;
 mod sri;
 mod wasm_bindgen;
@@ -20,7 +20,7 @@ use crate::{
         CargoMetadata,
     },
     pipelines::rust::{
-        gzip::GzipLevel,
+        compress::{CompressionAlgorithm, CompressionLevel},
         sri::{SriBuilder, SriOptions, SriType},
     },
     processing::{integrity::IntegrityType, minify::minify_js},
@@ -28,7 +28,6 @@ use crate::{
 };
 use anyhow::{anyhow, bail, ensure, Context, Result};
 use cargo_metadata::{Artifact, TargetKind};
-use flate2::bufread::GzEncoder;
 use minify_js::TopLevelMode;
 use seahash::SeaHasher;
 use std::{
@@ -102,8 +101,10 @@ pub struct RustApp {
     import_bindings_name: Option<String>,
     /// The name of the initializer module
     initializer: Option<PathBuf>,
-    /// Gzip compression level for the WASM file. Defaults to `GzipLevel::Default` on release build.
-    gzip_compression: GzipLevel,
+    /// Compression Algorithm for the WASM file.
+    compression_algorithm: CompressionAlgorithm,
+    /// Compression level for the WASM file. Defaults to `CompressionLevel::Default` on release build.
+    compression_level: CompressionLevel,
 }
 
 /// Describes how the rust application is used.
@@ -192,15 +193,20 @@ impl RustApp {
                 RustAppType::Main => WasmBindgenTarget::Web,
                 RustAppType::Worker => WasmBindgenTarget::NoModules,
             });
-        let gzip_compression = attrs
-            .get("data-gzip-compression")
+        let compression_algorithm = attrs
+            .get("data-compression-algorithm")
+            .map(|attr| attr.parse())
+            .transpose()?
+            .unwrap_or(CompressionAlgorithm::Gzip);
+        let compression_level = attrs
+            .get("data-compression-level")
             .map(|attr| attr.parse())
             .transpose()?
             .unwrap_or_else(|| {
                 if cfg.release {
                     Default::default()
                 } else {
-                    GzipLevel::OFF
+                    CompressionLevel::OFF
                 }
             });
         let cross_origin = attrs
@@ -325,7 +331,8 @@ impl RustApp {
             import_bindings_name,
             initializer,
             target_path,
-            gzip_compression
+            compression_algorithm,
+            compression_level,
         })
     }
 
@@ -376,7 +383,8 @@ impl RustApp {
             import_bindings_name: None,
             initializer: None,
             target_path: None,
-            gzip_compression: GzipLevel::OFF,
+            compression_algorithm: CompressionAlgorithm::Gzip,
+            compression_level: CompressionLevel::OFF,
         }))
     }
 
@@ -407,7 +415,7 @@ impl RustApp {
             .context("running wasm-opt")?;
 
         // (optionally) gzip the wasm file
-        self.gzip_compression(&output.wasm_output)
+        self.wasm_compression(&output.wasm_output)
             .await
             .context("gzip compression")?;
 
@@ -773,7 +781,11 @@ impl RustApp {
         };
 
         // return output
-
+        let compression_algorithm = if self.compression_level != CompressionLevel::OFF {
+            Some(self.compression_algorithm.to_string())
+        } else {
+            None
+        };
         Ok(RustAppOutput {
             id: self.id,
             cfg: self.cfg.clone(),
@@ -786,7 +798,7 @@ impl RustApp {
             import_bindings: self.import_bindings,
             import_bindings_name: self.import_bindings_name.clone(),
             initializer,
-            gzip_compression_enabled: self.gzip_compression != GzipLevel::OFF,
+            compression_algorithm,
             wasm_bindgen_features,
         })
     }
@@ -981,29 +993,32 @@ impl RustApp {
     }
 
     #[tracing::instrument(level = "trace", skip(self))]
-    async fn gzip_compression(&self, wasm_name: &str) -> Result<()> {
+    async fn wasm_compression(&self, wasm_name: &str) -> Result<()> {
         if !self.cfg.release {
             return Ok(());
         }
 
-        if self.gzip_compression == GzipLevel::OFF {
-            log::debug!("gzip compression is turned off");
+        if self.compression_level == CompressionLevel::OFF {
+            log::debug!("compression is turned off");
             return Ok(());
         }
 
-        let gzip_name = "wasm-gzip";
+        let compression_name = "wasm-compression";
         let mode_segment = if self.cfg.release { "release" } else { "debug" };
         let output = self
             .manifest
             .metadata
             .target_directory
-            .join(gzip_name)
+            .join(compression_name)
             .join(mode_segment);
         fs::create_dir_all(&output)
             .await
             .context("error creating wasm gzip compression output dir")?;
 
-        tracing::debug!("compressing with gzip level {}", self.gzip_compression.level());
+        tracing::debug!(
+            "compressing with gzip level {}",
+            self.compression_level.level()
+        );
         let output = output.join(format!("{}_bg.wasm", self.name));
         let target_wasm = self
             .cfg
@@ -1015,22 +1030,22 @@ impl RustApp {
         let target_wasm_file = std::fs::File::open(&target_wasm)
             .context("error opening wasm file for gzip compression")?;
         let target_wasm_reader = std::io::BufReader::new(target_wasm_file);
-        let mut encoder = GzEncoder::new(
-            target_wasm_reader,
-            *self.gzip_compression,
-        );
+        let mut encoder = self
+            .compression_algorithm
+            .encoder(target_wasm_reader, *self.compression_level);
 
-        let output_file = std::fs::File::create(&output)
-            .context("error creating gzip output file")?;
+        let output_file =
+            std::fs::File::create(&output).context("error creating compression output file")?;
         let mut output_writer = std::io::BufWriter::new(output_file);
         std::io::copy(&mut encoder, &mut output_writer)
-            .context("error writing gzip compressed wasm file")?;
+            .context("error writing compressed wasm file")?;
 
         // Copy the generated WASM file to the dist dir.
         tracing::debug!("copying generated wasm-opt artifact from '{output}' to '{target_wasm}'");
-        fs::copy(output, &target_wasm)
-            .await
-            .context("error copying (gzip compressed) wasm file to dist dir")?;
+        fs::copy(output, &target_wasm).await.context(format!(
+            "error copying ({} compressed) wasm file to dist dir",
+            self.compression_algorithm.to_string()
+        ))?;
 
         Ok(())
     }
diff --git a/src/pipelines/rust/output.rs b/src/pipelines/rust/output.rs
index 2ffbeca2..bf235dd1 100644
--- a/src/pipelines/rust/output.rs
+++ b/src/pipelines/rust/output.rs
@@ -29,8 +29,8 @@ pub struct RustAppOutput {
     pub import_bindings: bool,
     /// The name of the WASM bindings import
     pub import_bindings_name: Option<String>,
-    /// Gzip compression enabled for the WASM file
-    pub gzip_compression_enabled: bool,
+    /// Compression algorithm used for the WASM file
+    pub compression_algorithm: Option<String>,
     /// The target of the initializer module
     pub initializer: Option<String>,
     /// The features supported by the version of wasm-bindgen used
@@ -144,7 +144,7 @@ dispatchEvent(new CustomEvent("TrunkApplicationStarted", {detail: {wasm}}));
 
         match &self.initializer {
             None => {
-                if self.gzip_compression_enabled {
+                if let Some(algorithm) = &self.compression_algorithm {
                     format!(
                         r#"
 <script type="module"{nonce}>
@@ -154,7 +154,7 @@ if (!resp.ok) {{
     throw new Error('Failed to fetch WASM module: ' + resp.statusText);
 }}
 
-const decompressStream = resp.body.pipeThrough(new DecompressionStream('gzip'));
+const decompressStream = resp.body.pipeThrough(new DecompressionStream('{algorithm}'));
 const wasmBytes = await new Response(decompressStream).arrayBuffer();
 const wasm = await init({{ module_or_path: wasmBytes }});
 

From bcadb16637b0179d5de522b0890cf3afd39380c4 Mon Sep 17 00:00:00 2001
From: bigsaltyfishes <bigsaltyfishes@gmail.com>
Date: Mon, 9 Jun 2025 00:11:57 +0800
Subject: [PATCH 3/8] fix: set compression_algorithm to none on debug build

Signed-off-by: bigsaltyfishes <bigsaltyfishes@gmail.com>
---
 src/pipelines/rust/mod.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/pipelines/rust/mod.rs b/src/pipelines/rust/mod.rs
index 5934ad25..d15f06c0 100644
--- a/src/pipelines/rust/mod.rs
+++ b/src/pipelines/rust/mod.rs
@@ -781,11 +781,12 @@ impl RustApp {
         };
 
         // return output
-        let compression_algorithm = if self.compression_level != CompressionLevel::OFF {
-            Some(self.compression_algorithm.to_string())
-        } else {
-            None
-        };
+        let compression_algorithm =
+            if self.cfg.release && self.compression_level != CompressionLevel::OFF {
+                Some(self.compression_algorithm.to_string())
+            } else {
+                None
+            };
         Ok(RustAppOutput {
             id: self.id,
             cfg: self.cfg.clone(),

From 80bc851598fc789b7f7b3f7d5d9b899031cb3598 Mon Sep 17 00:00:00 2001
From: bigsaltyfishes <bigsaltyfishes@gmail.com>
Date: Tue, 10 Jun 2025 17:16:36 +0800
Subject: [PATCH 4/8] chore: make clippy happy

Signed-off-by: bigsaltyfishes <bigsaltyfishes@gmail.com>
---
 src/pipelines/rust/compress.rs | 28 ++++++++++------------------
 src/pipelines/rust/mod.rs      |  4 ++--
 2 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/pipelines/rust/compress.rs b/src/pipelines/rust/compress.rs
index c966f900..d4a162fc 100644
--- a/src/pipelines/rust/compress.rs
+++ b/src/pipelines/rust/compress.rs
@@ -30,6 +30,14 @@ impl CompressionAlgorithm {
             Self::Deflate => Box::new(DeflateEncoder::new(reader, level)),
         }
     }
+
+    pub fn as_string(&self) -> String {
+        match self {
+            Self::Gzip => "gzip".to_string(),
+            Self::Zlib => "deflate".to_string(),
+            Self::Deflate => "deflate-raw".to_string(),
+        }
+    }
 }
 
 impl FromStr for CompressionAlgorithm {
@@ -45,17 +53,7 @@ impl FromStr for CompressionAlgorithm {
     }
 }
 
-impl ToString for CompressionAlgorithm {
-    fn to_string(&self) -> String {
-        match self {
-            Self::Gzip => "gzip".to_string(),
-            Self::Zlib => "deflate".to_string(),
-            Self::Deflate => "deflate-raw".to_string(),
-        }
-    }
-}
-
-#[derive(PartialEq, Eq)]
+#[derive(Default, PartialEq, Eq)]
 pub struct CompressionLevel(Compression);
 
 impl CompressionLevel {
@@ -98,10 +96,4 @@ impl Deref for CompressionLevel {
     fn deref(&self) -> &Self::Target {
         &self.0
     }
-}
-
-impl Default for CompressionLevel {
-    fn default() -> Self {
-        Self(Compression::default())
-    }
-}
+}
\ No newline at end of file
diff --git a/src/pipelines/rust/mod.rs b/src/pipelines/rust/mod.rs
index d15f06c0..6f301bca 100644
--- a/src/pipelines/rust/mod.rs
+++ b/src/pipelines/rust/mod.rs
@@ -783,7 +783,7 @@ impl RustApp {
         // return output
         let compression_algorithm =
             if self.cfg.release && self.compression_level != CompressionLevel::OFF {
-                Some(self.compression_algorithm.to_string())
+                Some(self.compression_algorithm.as_string())
             } else {
                 None
             };
@@ -1045,7 +1045,7 @@ impl RustApp {
         tracing::debug!("copying generated wasm-opt artifact from '{output}' to '{target_wasm}'");
         fs::copy(output, &target_wasm).await.context(format!(
             "error copying ({} compressed) wasm file to dist dir",
-            self.compression_algorithm.to_string()
+            self.compression_algorithm.as_string()
         ))?;
 
         Ok(())

From d59f0657696cead35426dd7c947856a799d0f1fe Mon Sep 17 00:00:00 2001
From: bigsaltyfishes <bigsaltyfishes@gmail.com>
Date: Tue, 10 Jun 2025 17:20:05 +0800
Subject: [PATCH 5/8] pipelines: merge repeat initializer code

Signed-off-by: bigsaltyfishes <bigsaltyfishes@gmail.com>
---
 src/pipelines/rust/output.rs | 47 ++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/src/pipelines/rust/output.rs b/src/pipelines/rust/output.rs
index bf235dd1..39efa535 100644
--- a/src/pipelines/rust/output.rs
+++ b/src/pipelines/rust/output.rs
@@ -140,15 +140,9 @@ window.{bindings} = bindings;
 dispatchEvent(new CustomEvent("TrunkApplicationStarted", {detail: {wasm}}));
 "#;
 
-        let init_with_object = self.wasm_bindgen_features.init_with_object;
-
-        match &self.initializer {
-            None => {
-                if let Some(algorithm) = &self.compression_algorithm {
-                    format!(
-                        r#"
-<script type="module"{nonce}>
-import init{import} from '{base}{js}';
+        let compression = if let Some(algorithm) = &self.compression_algorithm {
+            format!(
+                r#"
 const resp = await fetch('{base}{wasm}');
 if (!resp.ok) {{
     throw new Error('Failed to fetch WASM module: ' + resp.statusText);
@@ -156,29 +150,34 @@ if (!resp.ok) {{
 
 const decompressStream = resp.body.pipeThrough(new DecompressionStream('{algorithm}'));
 const wasmBytes = await new Response(decompressStream).arrayBuffer();
-const wasm = await init({{ module_or_path: wasmBytes }});
+                "#
+            )
+        } else {
+            String::new()
+        };
 
-{bind}
-{fire}
-</script>"#,
-                    )
-                } else {
-                    format!(
-                        r#"
+        let init_with_object = self.wasm_bindgen_features.init_with_object;
+
+        match &self.initializer {
+            None => {
+                format!(
+                    r#"
 <script type="module"{nonce}>
 import init{import} from '{base}{js}';
+{compression}
 const wasm = await init({init_arg});
 
 {bind}
 {fire}
 </script>"#,
-                        init_arg = if init_with_object {
-                            format!("{{ module_or_path: '{base}{wasm}' }}")
-                        } else {
-                            format!("'{base}{wasm}'")
-                        }
-                    )
-                }
+                    init_arg = if self.compression_algorithm.is_some() {
+                        "{ module_or_path: wasmBytes }".to_string()
+                    } else if init_with_object {
+                        format!("{{ module_or_path: '{base}{wasm}' }}")
+                    } else {
+                        format!("'{base}{wasm}'")
+                    }
+                )
             }
             Some(initializer) => format!(
                 r#"

From a42dc047005bc97337a08e7e4ad9a64be65299f0 Mon Sep 17 00:00:00 2001
From: bigsaltyfishes <bigsaltyfishes@gmail.com>
Date: Tue, 10 Jun 2025 17:21:54 +0800
Subject: [PATCH 6/8] fix: pipelines: add missing compression support for
 custom initializer

Signed-off-by: bigsaltyfishes <bigsaltyfishes@gmail.com>
---
 src/pipelines/rust/initializer.js | 10 ++++++++--
 src/pipelines/rust/output.rs      |  7 ++++++-
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/pipelines/rust/initializer.js b/src/pipelines/rust/initializer.js
index 1a7ba223..a37c4da6 100644
--- a/src/pipelines/rust/initializer.js
+++ b/src/pipelines/rust/initializer.js
@@ -1,4 +1,4 @@
-async function __trunkInitializer(init, source, sourceSize, initializer, initWithObject) {
+async function __trunkInitializer(init, source, sourceSize, initializer, initWithObject, compressAlgorithm) {
   if (initializer === undefined) {
     return await init(initWithObject ? { module_or_path: source } : source);
   }
@@ -11,7 +11,6 @@ async function __trunkInitializer(init, source, sourceSize, initializer, initWit
 
   const response = fetch(source)
       .then((response) => {
-        const reader = response.body.getReader();
         const headers = response.headers;
         const status = response.status;
         const statusText = response.statusText;
@@ -19,6 +18,13 @@ async function __trunkInitializer(init, source, sourceSize, initializer, initWit
         const total = sourceSize;
         let current = 0;
 
+        let reader = undefined;
+        if (compressAlgorithm) {
+          reader = response.body.pipeThrough(new DecompressionStream(compressAlgorithm)).getReader();
+        } else {
+          reader = response.body.getReader();
+        }
+
         const stream = new ReadableStream({
           start(controller) {
             function push() {
diff --git a/src/pipelines/rust/output.rs b/src/pipelines/rust/output.rs
index 39efa535..d6505a45 100644
--- a/src/pipelines/rust/output.rs
+++ b/src/pipelines/rust/output.rs
@@ -187,13 +187,18 @@ const wasm = await init({init_arg});
 import init{import} from '{base}{js}';
 import initializer from '{base}{initializer}';
 
-const wasm = await __trunkInitializer(init, '{base}{wasm}', {size}, initializer(), {init_with_object});
+const wasm = await __trunkInitializer(init, '{base}{wasm}', {size}, initializer(), {init_with_object}{algorithm});
 
 {bind}
 {fire}
 </script>"#,
                 init = include_str!("initializer.js"),
                 size = self.wasm_size,
+                algorithm = if let Some(algorithm) = &self.compression_algorithm {
+                    format!(", '{algorithm}'")
+                } else {
+                    String::new()
+                },
             ),
         }
     }

From 4b7e6a178c2e319e5122b1a346716e2d9b89ea27 Mon Sep 17 00:00:00 2001
From: bigsaltyfishes <bigsaltyfishes@gmail.com>
Date: Tue, 10 Jun 2025 18:13:07 +0800
Subject: [PATCH 7/8] fix: pipelines: fix compression support when missing
 wasm-bingen feature `init_with_object`

Signed-off-by: bigsaltyfishes <bigsaltyfishes@gmail.com>
---
 src/pipelines/rust/output.rs | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/pipelines/rust/output.rs b/src/pipelines/rust/output.rs
index d6505a45..9e2a1145 100644
--- a/src/pipelines/rust/output.rs
+++ b/src/pipelines/rust/output.rs
@@ -170,12 +170,18 @@ const wasm = await init({init_arg});
 {bind}
 {fire}
 </script>"#,
-                    init_arg = if self.compression_algorithm.is_some() {
-                        "{ module_or_path: wasmBytes }".to_string()
-                    } else if init_with_object {
-                        format!("{{ module_or_path: '{base}{wasm}' }}")
-                    } else {
-                        format!("'{base}{wasm}'")
+                    init_arg = {
+                        let param = if self.compression_algorithm.is_some() {
+                            "wasmBytes".to_string()
+                        } else {
+                            format!("'{base}{wasm}'")
+                        };
+
+                        if init_with_object {
+                            format!("{{ module_or_path: {param} }}")
+                        } else {
+                            param
+                        }
                     }
                 )
             }

From 4758424b9c026b79cfe94fde1ef318df4f9c9216 Mon Sep 17 00:00:00 2001
From: bigsaltyfishes <bigsaltyfishes@gmail.com>
Date: Tue, 10 Jun 2025 19:19:55 +0800
Subject: [PATCH 8/8] fix: pipelines: lint fix

Signed-off-by: bigsaltyfishes <bigsaltyfishes@gmail.com>
---
 src/pipelines/rust/compress.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pipelines/rust/compress.rs b/src/pipelines/rust/compress.rs
index d4a162fc..0d11b6a1 100644
--- a/src/pipelines/rust/compress.rs
+++ b/src/pipelines/rust/compress.rs
@@ -96,4 +96,4 @@ impl Deref for CompressionLevel {
     fn deref(&self) -> &Self::Target {
         &self.0
     }
-}
\ No newline at end of file
+}