From 568d07448a187d4a118ed66ca9cac0720ca0b291 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Mon, 14 Apr 2025 14:53:48 -0500
Subject: [PATCH 01/11] Fix deduping assets

---
 Cargo.lock                                    |   9 +-
 packages/cli-opt/src/lib.rs                   |  64 ++++++-
 packages/cli/Cargo.toml                       |  28 ++-
 packages/cli/src/build/bundle.rs              |  84 ++++-----
 packages/cli/src/build/request.rs             |   6 -
 packages/cli/src/build/web.rs                 |  20 +-
 packages/cli/src/cli/link.rs                  | 169 +++++++++++++++--
 packages/cli/src/serve/handle.rs              |  26 +--
 packages/const-serialize/src/lib.rs           |   2 +-
 packages/manganis/manganis-core/src/asset.rs  |   1 +
 packages/manganis/manganis-core/src/css.rs    |   1 +
 packages/manganis/manganis-core/src/folder.rs |   1 +
 packages/manganis/manganis-core/src/images.rs |   3 +
 packages/manganis/manganis-core/src/js.rs     |   1 +
 .../manganis/manganis-core/src/options.rs     |   1 +
 packages/manganis/manganis-macro/src/asset.rs |  16 +-
 packages/manganis/manganis/src/hash.rs        |  39 ----
 packages/manganis/manganis/src/lib.rs         |   1 -
 .../manganis/manganis/src/macro_helpers.rs    | 171 +-----------------
 19 files changed, 312 insertions(+), 331 deletions(-)
 delete mode 100644 packages/manganis/manganis/src/hash.rs

diff --git a/Cargo.lock b/Cargo.lock
index 2ba68fa6e9..ce6a7095d3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2159,7 +2159,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
 dependencies = [
  "smallvec",
- "target-lexicon",
+ "target-lexicon 0.12.16",
 ]
 
 [[package]]
@@ -3600,6 +3600,7 @@ dependencies = [
  "strum 0.26.3",
  "syn 2.0.100",
  "tar",
+ "target-lexicon 0.13.2",
  "tauri-bundler",
  "tauri-utils",
  "tempfile",
@@ -13762,6 +13763,12 @@ version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
+[[package]]
+name = "target-lexicon"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+
 [[package]]
 name = "target-triple"
 version = "0.1.4"
diff --git a/packages/cli-opt/src/lib.rs b/packages/cli-opt/src/lib.rs
index 97c934a747..d3d36bcc8a 100644
--- a/packages/cli-opt/src/lib.rs
+++ b/packages/cli-opt/src/lib.rs
@@ -1,10 +1,13 @@
 use anyhow::Context;
+use manganis::AssetOptions;
 use manganis_core::linker::LinkSection;
 use manganis_core::BundledAsset;
 use object::{read::archive::ArchiveFile, File as ObjectFile, Object, ObjectSection};
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use serde::{Deserialize, Serialize};
-use std::path::Path;
-use std::{collections::HashMap, path::PathBuf};
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, RwLock};
 
 mod css;
 mod file;
@@ -21,7 +24,7 @@ pub use file::process_file_to;
 #[derive(Debug, PartialEq, Default, Clone, Serialize, Deserialize)]
 pub struct AssetManifest {
     /// Map of bundled asset name to the asset itself
-    pub assets: HashMap<PathBuf, BundledAsset>,
+    assets: HashMap<PathBuf, HashSet<BundledAsset>>,
 }
 
 impl AssetManifest {
@@ -31,21 +34,30 @@ impl AssetManifest {
         asset_path: &Path,
         options: manganis::AssetOptions,
     ) -> anyhow::Result<BundledAsset> {
-        let hash = manganis_core::hash::AssetHash::hash_file_contents(asset_path)
-            .context("Failed to hash file")?;
-
         let output_path_str = asset_path.to_str().ok_or(anyhow::anyhow!(
             "Failed to convert wasm bindgen output path to string"
         ))?;
 
-        let bundled_asset =
-            manganis::macro_helpers::create_bundled_asset(output_path_str, hash.bytes(), options);
+        let bundled_asset = manganis::macro_helpers::create_bundled_asset(output_path_str, options);
 
-        self.assets.insert(asset_path.into(), bundled_asset);
+        self.assets
+            .entry(asset_path.to_path_buf())
+            .or_default()
+            .insert(bundled_asset);
 
         Ok(bundled_asset)
     }
 
+    /// Get any assets that are tied to a specific source file
+    pub fn get_assets_for_source(&self, path: &Path) -> Option<&HashSet<BundledAsset>> {
+        self.assets.get(path)
+    }
+
+    /// Iterate over all the assets in the manifest
+    pub fn assets(&self) -> impl Iterator<Item = &BundledAsset> {
+        self.assets.values().flat_map(|assets| assets.iter())
+    }
+
     #[allow(dead_code)]
     pub fn load_from_file(path: &Path) -> anyhow::Result<Self> {
         let src = std::fs::read_to_string(path)?;
@@ -120,7 +132,9 @@ impl AssetManifest {
                 const_serialize::deserialize_const!(BundledAsset, buffer)
             {
                 self.assets
-                    .insert(asset.absolute_source_path().into(), asset);
+                    .entry(PathBuf::from(asset.absolute_source_path()))
+                    .or_default()
+                    .insert(asset);
                 buffer = remaining_buffer;
             }
         }
@@ -128,3 +142,33 @@ impl AssetManifest {
         Ok(())
     }
 }
+
+/// Optimize a list of assets in parallel
+pub fn optimize_all_assets(
+    assets_to_transfer: Vec<(PathBuf, PathBuf, AssetOptions)>,
+    on_optimization_start: impl FnMut(&Path, &Path, &AssetOptions) + Sync + Send,
+    on_optimization_end: impl FnMut(&Path, &Path, &AssetOptions) + Sync + Send,
+) -> anyhow::Result<()> {
+    let on_optimization_start = Arc::new(RwLock::new(on_optimization_start));
+    let on_optimization_end = Arc::new(RwLock::new(on_optimization_end));
+    assets_to_transfer
+        .par_iter()
+        .try_for_each(|(from, to, options)| {
+            {
+                let mut on_optimization_start = on_optimization_start.write().unwrap();
+                on_optimization_start(from, to, options);
+            }
+
+            let res = process_file_to(options, from, to);
+            if let Err(err) = res.as_ref() {
+                tracing::error!("Failed to copy asset {from:?}: {err}");
+            }
+
+            {
+                let mut on_optimization_end = on_optimization_end.write().unwrap();
+                on_optimization_end(from, to, options);
+            }
+
+            res.map(|_| ())
+        })
+}
diff --git a/packages/cli/Cargo.toml b/packages/cli/Cargo.toml
index 958bd9603b..a007c9ea1b 100644
--- a/packages/cli/Cargo.toml
+++ b/packages/cli/Cargo.toml
@@ -58,7 +58,12 @@ axum-server = { workspace = true, features = ["tls-rustls"] }
 axum-extra = { workspace = true, features = ["typed-header"] }
 tower-http = { workspace = true, features = ["full"] }
 proc-macro2 = { workspace = true, features = ["span-locations"] }
-syn = { workspace = true, features = ["full", "extra-traits", "visit", "visit-mut"] }
+syn = { workspace = true, features = [
+    "full",
+    "extra-traits",
+    "visit",
+    "visit-mut",
+] }
 
 headers = "0.4.0"
 walkdir = "2"
@@ -66,11 +71,7 @@ dunce = { workspace = true }
 
 # tools download
 dirs = { workspace = true }
-reqwest = { workspace = true, features = [
-    "rustls-tls",
-    "trust-dns",
-    "json"
-] }
+reqwest = { workspace = true, features = ["rustls-tls", "trust-dns", "json"] }
 tower = { workspace = true }
 once_cell = "1.19.0"
 
@@ -92,7 +93,13 @@ ignore = "0.4.22"
 env_logger = { workspace = true }
 const-serialize = { workspace = true, features = ["serde"] }
 
-tracing-subscriber = { version = "0.3.18", features = ["std", "env-filter", "json", "registry", "fmt"] }
+tracing-subscriber = { version = "0.3.18", features = [
+    "std",
+    "env-filter",
+    "json",
+    "registry",
+    "fmt",
+] }
 console-subscriber = { version = "0.3.0", optional = true }
 tracing = { workspace = true }
 wasm-opt = { version = "0.116.1", optional = true }
@@ -109,9 +116,10 @@ log = { version = "0.4", features = ["max_level_off", "release_max_level_off"] }
 tempfile = "3.3"
 manganis = { workspace = true }
 manganis-core = { workspace = true }
+target-lexicon = "0.13.2"
 
 # Extracting data from an executable
-object = {version="0.36.0", features=["wasm"]}
+object = { version = "0.36.0", features = ["wasm"] }
 tokio-util = { version = "0.7.11", features = ["full"] }
 itertools = "0.13.0"
 throbber-widgets-tui = "=0.7.0"
@@ -162,5 +170,5 @@ pkg-fmt = "zip"
 
 [package.metadata.docs.rs]
 all-features = false
-rustc-args = [ "--cfg", "docsrs" ]
-rustdoc-args = [ "--cfg", "docsrs" ]
+rustc-args = ["--cfg", "docsrs"]
+rustdoc-args = ["--cfg", "docsrs"]
diff --git a/packages/cli/src/build/bundle.rs b/packages/cli/src/build/bundle.rs
index e2b769f9d2..7753a4efaa 100644
--- a/packages/cli/src/build/bundle.rs
+++ b/packages/cli/src/build/bundle.rs
@@ -3,9 +3,8 @@ use super::templates::InfoPlistData;
 use crate::{BuildRequest, Platform, WasmOptConfig};
 use crate::{Result, TraceSrc};
 use anyhow::Context;
-use dioxus_cli_opt::{process_file_to, AssetManifest};
+use dioxus_cli_opt::{optimize_all_assets, AssetManifest};
 use manganis::{AssetOptions, JsAssetOptions};
-use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
 use std::future::Future;
 use std::path::{Path, PathBuf};
 use std::pin::Pin;
@@ -354,38 +353,19 @@ impl AppBundle {
         Ok(())
     }
 
-    /// Copy the assets out of the manifest and into the target location
-    ///
-    /// Should be the same on all platforms - just copy over the assets from the manifest into the output directory
-    async fn write_assets(&self) -> Result<()> {
-        // Server doesn't need assets - web will provide them
-        if self.build.build.platform() == Platform::Server {
-            return Ok(());
-        }
-
+    /// Clean up any assets that no longer exist in the manifest
+    async fn clear_old_assets(&self) -> Result<()> {
         let asset_dir = self.build.asset_dir();
 
         // First, clear the asset dir of any files that don't exist in the new manifest
         _ = tokio::fs::create_dir_all(&asset_dir).await;
         // Create a set of all the paths that new files will be bundled to
-        let mut keep_bundled_output_paths: HashSet<_> = self
+        let keep_bundled_output_paths: HashSet<_> = self
             .app
             .assets
-            .assets
-            .values()
+            .assets()
             .map(|a| asset_dir.join(a.bundled_path()))
             .collect();
-        // The CLI creates a .version file in the asset dir to keep track of what version of the optimizer
-        // the asset was processed. If that version doesn't match the CLI version, we need to re-optimize
-        // all assets.
-        let version_file = self.build.asset_optimizer_version_file();
-        let clear_cache = std::fs::read_to_string(&version_file)
-            .ok()
-            .filter(|s| s == crate::VERSION.as_str())
-            .is_none();
-        if clear_cache {
-            keep_bundled_output_paths.clear();
-        }
 
         // one possible implementation of walking a directory only visiting files
         fn remove_old_assets<'a>(
@@ -425,24 +405,40 @@ impl AppBundle {
         );
         remove_old_assets(&asset_dir, &keep_bundled_output_paths).await?;
 
+        Ok(())
+    }
+
+    /// Copy the assets out of the manifest and into the target location
+    ///
+    /// Should be the same on all platforms - just copy over the assets from the manifest into the output directory
+    async fn write_assets(&self) -> Result<()> {
+        // Server doesn't need assets - web will provide them
+        if self.build.build.platform() == Platform::Server {
+            return Ok(());
+        }
+
+        self.clear_old_assets();
+
+        let asset_dir = self.build.asset_dir();
+
         // todo(jon): we also want to eventually include options for each asset's optimization and compression, which we currently aren't
         let mut assets_to_transfer = vec![];
 
         // Queue the bundled assets
-        for (asset, bundled) in &self.app.assets.assets {
-            let from = asset.clone();
-            let to = asset_dir.join(bundled.bundled_path());
+        for asset in self.app.assets.assets() {
+            let from = PathBuf::from(asset.absolute_source_path());
+            let to = asset_dir.join(asset.bundled_path());
 
             // prefer to log using a shorter path relative to the workspace dir by trimming the workspace dir
             let from_ = from
                 .strip_prefix(self.build.krate.workspace_dir())
                 .unwrap_or(from.as_path());
-            let to_ = from
+            let to_ = to
                 .strip_prefix(self.build.krate.workspace_dir())
                 .unwrap_or(to.as_path());
 
             tracing::debug!("Copying asset {from_:?} to {to_:?}");
-            assets_to_transfer.push((from, to, *bundled.options()));
+            assets_to_transfer.push((from, to, *asset.options()));
         }
 
         // And then queue the legacy assets
@@ -462,20 +458,16 @@ impl AppBundle {
         let ws_dir = self.build.krate.workspace_dir();
         // Optimizing assets is expensive and blocking, so we do it in a tokio spawn blocking task
         tokio::task::spawn_blocking(move || {
-            assets_to_transfer
-                .par_iter()
-                .try_for_each(|(from, to, options)| {
+            optimize_all_assets(
+                assets_to_transfer,
+                |from, _, _| {
                     let processing = started_processing.fetch_add(1, Ordering::SeqCst);
                     let from_ = from.strip_prefix(&ws_dir).unwrap_or(from);
                     tracing::trace!(
                         "Starting asset copy {processing}/{asset_count} from {from_:?}"
                     );
-
-                    let res = process_file_to(options, from, to);
-                    if let Err(err) = res.as_ref() {
-                        tracing::error!("Failed to copy asset {from:?}: {err}");
-                    }
-
+                },
+                |from, _, _| {
                     let finished = copied.fetch_add(1, Ordering::SeqCst);
                     BuildRequest::status_copied_asset(
                         &progress,
@@ -483,22 +475,12 @@ impl AppBundle {
                         asset_count,
                         from.to_path_buf(),
                     );
-
-                    res.map(|_| ())
-                })
+                },
+            )
         })
         .await
         .map_err(|e| anyhow::anyhow!("A task failed while trying to copy assets: {e}"))??;
 
-        // // Remove the wasm bindgen output directory if it exists
-        // _ = std::fs::remove_dir_all(self.build.wasm_bindgen_out_dir());
-
-        // Write the version file so we know what version of the optimizer we used
-        std::fs::write(
-            self.build.asset_optimizer_version_file(),
-            crate::VERSION.as_str(),
-        )?;
-
         Ok(())
     }
 
diff --git a/packages/cli/src/build/request.rs b/packages/cli/src/build/request.rs
index 77d9464dbf..fadb551d36 100644
--- a/packages/cli/src/build/request.rs
+++ b/packages/cli/src/build/request.rs
@@ -463,7 +463,6 @@ impl BuildRequest {
     ///
     /// There's a chance that's not actually true, so this function is kept around in case we do
     /// need to revert to "deep extraction".
-    #[allow(unused)]
     async fn deep_linker_asset_extract(&self) -> Result<AssetManifest> {
         // Create a temp file to put the output of the args
         // We need to do this since rustc won't actually print the link args to stdout, so we need to
@@ -751,11 +750,6 @@ impl BuildRequest {
         }
     }
 
-    /// Get the path to the asset optimizer version file
-    pub fn asset_optimizer_version_file(&self) -> PathBuf {
-        self.platform_dir().join(".cli-version")
-    }
-
     pub fn platform_exe_name(&self) -> String {
         match self.build.platform() {
             Platform::MacOS => self.krate.executable_name().to_string(),
diff --git a/packages/cli/src/build/web.rs b/packages/cli/src/build/web.rs
index 52b2e8e914..b040d43676 100644
--- a/packages/cli/src/build/web.rs
+++ b/packages/cli/src/build/web.rs
@@ -85,7 +85,7 @@ impl AppBundle {
         }
 
         // Inject any resources from manganis into the head
-        for asset in self.app.assets.assets.values() {
+        for asset in self.app.assets.assets() {
             let asset_path = asset.bundled_path();
             match asset.options() {
                 AssetOptions::Css(css_options) => {
@@ -117,9 +117,11 @@ impl AppBundle {
         let wasm_path = self
             .app
             .assets
-            .assets
-            .get(&wasm_source_path)
+            .get_assets_for_source(&wasm_source_path)
             .expect("WASM asset should exist in web bundles")
+            .iter()
+            .next()
+            .expect("Should only be one wasm asset")
             .bundled_path();
         head_resources.push_str(&format!(
             "<link rel=\"preload\" as=\"fetch\" type=\"application/wasm\" href=\"/{{base_path}}/assets/{wasm_path}\" crossorigin>"
@@ -177,18 +179,22 @@ r#" <script>
         let wasm_path = self
             .app
             .assets
-            .assets
-            .get(&wasm_source_path)
+            .get_assets_for_source(&wasm_source_path)
             .expect("WASM asset should exist in web bundles")
+            .iter()
+            .next()
+            .expect("Should only be one wasm asset")
             .bundled_path();
         let wasm_path = format!("assets/{wasm_path}");
         let js_source_path = self.build.wasm_bindgen_js_output_file();
         let js_path = self
             .app
             .assets
-            .assets
-            .get(&js_source_path)
+            .get_assets_for_source(&js_source_path)
             .expect("JS asset should exist in web bundles")
+            .iter()
+            .next()
+            .expect("Should only be one js asset")
             .bundled_path();
         let js_path = format!("assets/{js_path}");
 
diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index a4711bd337..f063bda954 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -1,6 +1,15 @@
-use dioxus_cli_opt::AssetManifest;
+use const_serialize::{deserialize_const, ConstVec};
+use manganis::BundledAsset;
+use object::{Object, ObjectSection, ReadCache};
 use serde::{Deserialize, Serialize};
+use std::error::Error;
+use std::fmt::Debug;
+use std::fs;
+use std::io::{Read, Seek, Write};
+use std::ops::Range;
 use std::path::PathBuf;
+use std::process::Command;
+use target_lexicon::Triple;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum LinkAction {
@@ -56,8 +65,9 @@ impl LinkAction {
 
             // Assemble an asset manifest by walking the object files being passed to us
             LinkAction::BuildAssetManifest { destination: dest } => {
-                let mut args: Vec<_> = std::env::args().collect();
-                let mut manifest = AssetManifest::default();
+                let args: Vec<_> = std::env::args().collect();
+                let mut obj_args = args.clone();
+                let mut manifest = AssetReferences::default();
 
                 // Handle command files, usually a windows thing.
                 if let Some(command) = args.iter().find(|arg| arg.starts_with('@')).cloned() {
@@ -76,7 +86,7 @@ impl LinkAction {
                     });
 
                     // Gather linker args, and reset the args to be just the linker args
-                    args = content
+                    obj_args = content
                         .lines()
                         .map(|line| {
                             let line_parsed = line.to_string();
@@ -88,18 +98,153 @@ impl LinkAction {
                 }
 
                 // Parse through linker args for `.o` or `.rlib` files.
-                for item in args {
-                    if item.ends_with(".o") || item.ends_with(".rlib") {
-                        let path_to_item = PathBuf::from(item);
-                        if let Ok(path) = path_to_item.canonicalize() {
-                            _ = manifest.add_from_object_path(&path);
-                        }
+                obj_args.retain(|item| item.ends_with(".o") || item.ends_with(".rlib"));
+                for item in obj_args {
+                    let path_to_item = PathBuf::from(item);
+                    if let Ok(path) = path_to_item.canonicalize() {
+                        _ = manifest.add_from_object_path(&path);
                     }
                 }
 
-                let contents = serde_json::to_string(&manifest).expect("Failed to write manifest");
-                std::fs::write(dest, contents).expect("Failed to write output file");
+                // let contents = serde_json::to_string(&manifest).expect("Failed to write manifest");
+                // std::fs::write(dest, contents).expect("Failed to write output file");
+
+                // forward the modified object files to the real linker
+                let err_file = std::fs::File::options()
+                    .append(true)
+                    .create(true)
+                    .open("/Users/evanalmloff/Desktop/Github/dioxus-test/linker_err.txt")
+                    .unwrap();
+                let toolchain = if args.contains(&"wasm".to_string()) {
+                    "stable-wasm32-unknown-unknown".to_string()
+                } else {
+                    std::env::var("RUSTUP_TOOLCHAIN").unwrap()
+                };
+
+                let mut linker_command = find_linker(toolchain);
+                let status = linker_command
+                    .args(args.into_iter().skip(1))
+                    .stderr(err_file)
+                    .status()
+                    .expect("Failed to spawn linker");
+
+                if let Some(code) = status.code() {
+                    std::process::exit(code);
+                }
+            }
+        }
+    }
+}
+
+struct AssetReference {
+    file: PathBuf,
+    byte_span: Range<usize>,
+    bundled_asset: BundledAsset,
+}
+
+impl AssetReference {
+    fn write(&self, new_data: &[u8]) -> std::io::Result<()> {
+        let mut binary_data = fs::File::options()
+            .write(true)
+            .read(true)
+            .open(&self.file)?;
+        binary_data.seek(std::io::SeekFrom::Start(self.byte_span.start as u64))?;
+        // Write the modified binary data back to the file
+        binary_data.write_all(&new_data)?;
+        binary_data.sync_all()
+    }
+}
+
+#[derive(Default)]
+struct AssetReferences {
+    assets: Vec<AssetReference>,
+}
+
+impl AssetReferences {
+    fn new() -> Self {
+        Self { assets: Vec::new() }
+    }
+
+    fn add_from_object_path(&mut self, path: &PathBuf) -> Result<(), Box<dyn Error>> {
+        let mut binary_data = fs::File::options().read(true).open(path)?;
+        let mut range = None;
+        {
+            let read_cache = ReadCache::new(&mut binary_data);
+            let file = object::File::parse(&read_cache)?;
+            for section in file.sections() {
+                if section.name()? == "manganis" && section.segment_name()? == Some("__DATA") {
+                    if file.format() == object::BinaryFormat::Wasm {
+                        // In wasm this is actually the start and end
+                        let (start, end) = section.file_range().unwrap();
+                        range = Some(start as usize..end as usize);
+                    } else {
+                        let (offset, len) = section.file_range().unwrap();
+                        range = Some(offset as usize..(offset + len) as usize);
+                    }
+                    break;
+                }
+            }
+        }
+        if let Some(range) = range {
+            binary_data.seek(std::io::SeekFrom::Start(range.start as u64))?;
+            let mut data_in_range = vec![0; range.len()];
+            binary_data.read_exact(&mut data_in_range)?;
+            for offset in (0..data_in_range.len()).step_by(std::mem::size_of::<BundledAsset>()) {
+                let range = (range.start + offset)
+                    ..(range.start + offset + std::mem::size_of::<BundledAsset>());
+                let const_vec = ConstVec::new().extend(&data_in_range[range.clone()]);
+                if let Some((_, bundled_asset)) = deserialize_const!(BundledAsset, const_vec.read())
+                {
+                    self.assets.push(AssetReference {
+                        file: path.clone(),
+                        byte_span: range,
+                        bundled_asset,
+                    });
+                }
             }
         }
+        Ok(())
+    }
+}
+
+// find the current linker
+fn find_linker(toolchain: String) -> Command {
+    let target = toolchain.split("-").nth(1).unwrap();
+    match target {
+        // usually just ld64 - uses your `cc`
+        "aarch64" => {
+            // env -u IPHONEOS_DEPLOYMENT_TARGET -u TVOS_DEPLOYMENT_TARGET -u XROS_DEPLOYMENT_TARGET LC_ALL="C" "cc"
+            let mut command = Command::new(PathBuf::from("cc"));
+            command.env_remove("IPHONEOS_DEPLOYMENT_TARGET");
+            command.env_remove("TVOS_DEPLOYMENT_TARGET");
+            command.env_remove("XROS_DEPLOYMENT_TARGET");
+            command
+        }
+        "wasm32" => {
+            let mut command = Command::new(wasm_ld());
+            command.env("LC_ALL", "C");
+            command
+        }
+        _ => todo!("Unsupported target: {}", target),
     }
 }
+
+fn wasm_ld() -> PathBuf {
+    // eg. /Users/jonkelley/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/aarch64-apple-darwin/bin/rust-lld
+    //     |_________________________sysroot_____________________________|
+    //
+    // we should opt to use rust-lld since that's the default on linux and will eventually be the default on windows
+    // I think mac will keep ld
+    let root = Command::new("rustc")
+        .arg("--print")
+        .arg("sysroot")
+        .output()
+        .unwrap();
+    let root = PathBuf::from(String::from_utf8(root.stdout).unwrap().trim())
+        .join("lib")
+        .join("rustlib")
+        .join(Triple::host().to_string())
+        .join("bin")
+        .join("rust-lld");
+    root
+}
diff --git a/packages/cli/src/serve/handle.rs b/packages/cli/src/serve/handle.rs
index 7037baa61f..e922859a29 100644
--- a/packages/cli/src/serve/handle.rs
+++ b/packages/cli/src/serve/handle.rs
@@ -279,18 +279,20 @@ impl AppHandle {
             .ok()?;
 
         // The asset might've been renamed thanks to the manifest, let's attempt to reload that too
-        if let Some(resource) = self.app.app.assets.assets.get(&changed_file).as_ref() {
-            let output_path = asset_dir.join(resource.bundled_path());
-            // Remove the old asset if it exists
-            _ = std::fs::remove_file(&output_path);
-            // And then process the asset with the options into the **old** asset location. If we recompiled,
-            // the asset would be in a new location because the contents and hash have changed. Since we are
-            // hotreloading, we need to use the old asset location it was originally written to.
-            let options = *resource.options();
-            let res = process_file_to(&options, &changed_file, &output_path);
-            bundled_name = Some(PathBuf::from(resource.bundled_path()));
-            if let Err(e) = res {
-                tracing::debug!("Failed to hotreload asset {e}");
+        if let Some(resources) = self.app.app.assets.get_assets_for_source(&changed_file) {
+            for resource in resources {
+                let output_path = asset_dir.join(resource.bundled_path());
+                // Remove the old asset if it exists
+                _ = std::fs::remove_file(&output_path);
+                // And then process the asset with the options into the **old** asset location. If we recompiled,
+                // the asset would be in a new location because the contents and hash have changed. Since we are
+                // hotreloading, we need to use the old asset location it was originally written to.
+                let options = *resource.options();
+                let res = process_file_to(&options, &changed_file, &output_path);
+                bundled_name = Some(PathBuf::from(resource.bundled_path()));
+                if let Err(e) = res {
+                    tracing::debug!("Failed to hotreload asset {e}");
+                }
             }
         }
 
diff --git a/packages/const-serialize/src/lib.rs b/packages/const-serialize/src/lib.rs
index 6a911be6bd..35cdf551d4 100644
--- a/packages/const-serialize/src/lib.rs
+++ b/packages/const-serialize/src/lib.rs
@@ -221,7 +221,7 @@ impl_serialize_const_tuple!(T1: 0, T2: 1, T3: 2, T4: 3, T5: 4, T6: 5, T7: 6, T8:
 const MAX_STR_SIZE: usize = 256;
 
 /// A string that is stored in a constant sized buffer that can be serialized and deserialized at compile time
-#[derive(PartialEq, PartialOrd, Clone, Copy, Hash)]
+#[derive(Eq, PartialEq, PartialOrd, Clone, Copy, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ConstStr {
     #[cfg_attr(feature = "serde", serde(with = "serde_bytes"))]
diff --git a/packages/manganis/manganis-core/src/asset.rs b/packages/manganis/manganis-core/src/asset.rs
index 28434b5382..72e531bd50 100644
--- a/packages/manganis/manganis-core/src/asset.rs
+++ b/packages/manganis/manganis-core/src/asset.rs
@@ -9,6 +9,7 @@ use std::path::PathBuf;
 /// to use.
 #[derive(
     Debug,
+    Eq,
     PartialEq,
     PartialOrd,
     Clone,
diff --git a/packages/manganis/manganis-core/src/css.rs b/packages/manganis/manganis-core/src/css.rs
index 974defd44c..c5adaaaf83 100644
--- a/packages/manganis/manganis-core/src/css.rs
+++ b/packages/manganis/manganis-core/src/css.rs
@@ -5,6 +5,7 @@ use crate::AssetOptions;
 /// Options for a css asset
 #[derive(
     Debug,
+    Eq,
     PartialEq,
     PartialOrd,
     Clone,
diff --git a/packages/manganis/manganis-core/src/folder.rs b/packages/manganis/manganis-core/src/folder.rs
index 06127cf093..e1f62b8468 100644
--- a/packages/manganis/manganis-core/src/folder.rs
+++ b/packages/manganis/manganis-core/src/folder.rs
@@ -5,6 +5,7 @@ use crate::AssetOptions;
 /// The builder for [`FolderAsset`]
 #[derive(
     Debug,
+    Eq,
     PartialEq,
     PartialOrd,
     Clone,
diff --git a/packages/manganis/manganis-core/src/images.rs b/packages/manganis/manganis-core/src/images.rs
index a51b858661..36d9d30d0b 100644
--- a/packages/manganis/manganis-core/src/images.rs
+++ b/packages/manganis/manganis-core/src/images.rs
@@ -5,6 +5,7 @@ use crate::AssetOptions;
 /// The type of an image. You can read more about the tradeoffs between image formats [here](https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Image_types)
 #[derive(
     Debug,
+    Eq,
     PartialEq,
     PartialOrd,
     Clone,
@@ -31,6 +32,7 @@ pub enum ImageFormat {
 /// The size of an image asset
 #[derive(
     Debug,
+    Eq,
     PartialEq,
     PartialOrd,
     Clone,
@@ -56,6 +58,7 @@ pub enum ImageSize {
 /// Options for an image asset
 #[derive(
     Debug,
+    Eq,
     PartialEq,
     PartialOrd,
     Clone,
diff --git a/packages/manganis/manganis-core/src/js.rs b/packages/manganis/manganis-core/src/js.rs
index 8c284ba448..3bb2d1d37d 100644
--- a/packages/manganis/manganis-core/src/js.rs
+++ b/packages/manganis/manganis-core/src/js.rs
@@ -5,6 +5,7 @@ use crate::AssetOptions;
 /// Options for a javascript asset
 #[derive(
     Debug,
+    Eq,
     PartialEq,
     PartialOrd,
     Clone,
diff --git a/packages/manganis/manganis-core/src/options.rs b/packages/manganis/manganis-core/src/options.rs
index 714c1f9007..c6a9b82318 100644
--- a/packages/manganis/manganis-core/src/options.rs
+++ b/packages/manganis/manganis-core/src/options.rs
@@ -5,6 +5,7 @@ use crate::{CssAssetOptions, FolderAssetOptions, ImageAssetOptions, JsAssetOptio
 /// Settings for a generic asset
 #[derive(
     Debug,
+    Eq,
     PartialEq,
     PartialOrd,
     Clone,
diff --git a/packages/manganis/manganis-macro/src/asset.rs b/packages/manganis/manganis-macro/src/asset.rs
index 482569849a..0cd323b5f3 100644
--- a/packages/manganis/manganis-macro/src/asset.rs
+++ b/packages/manganis/manganis-macro/src/asset.rs
@@ -1,5 +1,4 @@
 use macro_string::MacroString;
-use manganis_core::hash::AssetHash;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::{quote, ToTokens, TokenStreamExt};
 use std::{iter, path::PathBuf};
@@ -141,17 +140,6 @@ impl ToTokens for AssetParser {
         let mut asset_str = proc_macro2::Literal::string(&asset_str);
         asset_str.set_span(self.path_expr.span());
 
-        let hash = match AssetHash::hash_file_contents(asset) {
-            Ok(hash) => hash,
-            Err(err) => {
-                let err = err.to_string();
-                tokens.append_all(quote! { compile_error!(#err) });
-                return;
-            }
-        };
-
-        let hash = hash.bytes();
-
         // Generate the link section for the asset
         // The link section includes the source path and the output path of the asset
         let link_section = crate::generate_link_section(quote!(__ASSET));
@@ -171,8 +159,6 @@ impl ToTokens for AssetParser {
 
         tokens.extend(quote! {
             {
-                // We keep a hash of the contents of the asset for cache busting
-                const __ASSET_HASH: &[u8] = &[#(#hash),*];
                 // The source is used by the CLI to copy the asset
                 const __ASSET_SOURCE_PATH: &'static str = #asset_str;
                 // The options give the CLI info about how to process the asset
@@ -181,7 +167,7 @@ impl ToTokens for AssetParser {
                 const __ASSET_OPTIONS: manganis::AssetOptions = #options.into_asset_options();
                 // Create the asset that the crate will use. This is used both in the return value and
                 // added to the linker for the bundler to copy later
-                const __ASSET: manganis::BundledAsset = manganis::macro_helpers::#constructor(__ASSET_SOURCE_PATH, __ASSET_HASH, __ASSET_OPTIONS);
+                const __ASSET: manganis::BundledAsset = manganis::macro_helpers::#constructor(__ASSET_SOURCE_PATH, __ASSET_OPTIONS);
 
                 #link_section
 
diff --git a/packages/manganis/manganis/src/hash.rs b/packages/manganis/manganis/src/hash.rs
deleted file mode 100644
index 98dbb9252e..0000000000
--- a/packages/manganis/manganis/src/hash.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use const_serialize::{serialize_const, ConstVec, SerializeConst};
-
-// From rustchash -  https://github.com/rust-lang/rustc-hash/blob/6745258da00b7251bed4a8461871522d0231a9c7/src/lib.rs#L98
-const K: u64 = 0xf1357aea2e62a9c5;
-
-pub(crate) struct ConstHasher {
-    hash: u64,
-}
-
-impl ConstHasher {
-    pub const fn new() -> Self {
-        Self { hash: 0 }
-    }
-
-    pub const fn finish(&self) -> u64 {
-        self.hash
-    }
-
-    pub const fn write(mut self, bytes: &[u8]) -> Self {
-        let mut i = 0;
-        while i < bytes.len() {
-            self = self.write_byte(bytes[i]);
-            i += 1;
-        }
-        self
-    }
-
-    pub const fn write_byte(mut self, byte: u8) -> Self {
-        self.hash = self.hash.wrapping_add(byte as u64).wrapping_mul(K);
-        self
-    }
-
-    pub const fn hash_by_bytes<T: SerializeConst>(self, item: &T) -> Self {
-        let mut bytes = ConstVec::new();
-        bytes = serialize_const(item, bytes);
-        let bytes = bytes.as_ref();
-        self.write(bytes)
-    }
-}
diff --git a/packages/manganis/manganis/src/lib.rs b/packages/manganis/manganis/src/lib.rs
index 5e5b949bda..453267dd1c 100644
--- a/packages/manganis/manganis/src/lib.rs
+++ b/packages/manganis/manganis/src/lib.rs
@@ -1,7 +1,6 @@
 #![doc = include_str!("../README.md")]
 #![deny(missing_docs)]
 
-mod hash;
 #[doc(hidden)]
 pub mod macro_helpers;
 pub use manganis_macro::asset;
diff --git a/packages/manganis/manganis/src/macro_helpers.rs b/packages/manganis/manganis/src/macro_helpers.rs
index 8da971fa5f..6cad5a2801 100644
--- a/packages/manganis/manganis/src/macro_helpers.rs
+++ b/packages/manganis/manganis/src/macro_helpers.rs
@@ -2,16 +2,12 @@ pub use const_serialize;
 use const_serialize::{serialize_const, ConstStr, ConstVec};
 use manganis_core::{AssetOptions, BundledAsset};
 
-use crate::hash::ConstHasher;
+const PLACEHOLDER_HASH: ConstStr =
+    ConstStr::new("this is a placeholder path which will be replaced by the linker");
 
 /// Create a bundled asset from the input path, the content hash, and the asset options
-pub const fn create_bundled_asset(
-    input_path: &str,
-    content_hash: &[u8],
-    asset_config: AssetOptions,
-) -> BundledAsset {
-    let hashed_path = generate_unique_path_with_byte_hash(input_path, content_hash, &asset_config);
-    BundledAsset::new_from_const(ConstStr::new(input_path), hashed_path, asset_config)
+pub const fn create_bundled_asset(input_path: &str, asset_config: AssetOptions) -> BundledAsset {
+    BundledAsset::new_from_const(ConstStr::new(input_path), PLACEHOLDER_HASH, asset_config)
 }
 
 /// Create a bundled asset from the input path, the content hash, and the asset options with a relative asset deprecation warning
@@ -22,166 +18,9 @@ pub const fn create_bundled_asset(
 )]
 pub const fn create_bundled_asset_relative(
     input_path: &str,
-    content_hash: &[u8],
     asset_config: AssetOptions,
 ) -> BundledAsset {
-    create_bundled_asset(input_path, content_hash, asset_config)
-}
-
-/// Format the input path with a hash to create an unique output path for the macro in the form `{input_path}-{hash}.{extension}`
-pub const fn generate_unique_path(
-    input_path: &str,
-    content_hash: u64,
-    asset_config: &AssetOptions,
-) -> ConstStr {
-    let byte_hash = content_hash.to_le_bytes();
-    generate_unique_path_with_byte_hash(input_path, &byte_hash, asset_config)
-}
-
-/// Format the input path with a hash to create an unique output path for the macro in the form `{input_path}-{hash}.{extension}`
-const fn generate_unique_path_with_byte_hash(
-    input_path: &str,
-    content_hash: &[u8],
-    asset_config: &AssetOptions,
-) -> ConstStr {
-    // Format the unique path with the format `{input_path}-{hash}.{extension}`
-    // Start with the input path
-    let mut input_path = ConstStr::new(input_path);
-    // Then strip the prefix from the input path. The path comes from the build platform, but
-    // in wasm, we don't know what the path separator is from the build platform. We need to
-    // split by both unix and windows paths and take the smallest one
-    let mut extension = None;
-    match (input_path.rsplit_once('/'), input_path.rsplit_once('\\')) {
-        (Some((_, unix_new_input_path)), Some((_, windows_new_input_path))) => {
-            input_path = if unix_new_input_path.len() < windows_new_input_path.len() {
-                unix_new_input_path
-            } else {
-                windows_new_input_path
-            };
-        }
-        (Some((_, unix_new_input_path)), _) => {
-            input_path = unix_new_input_path;
-        }
-        (_, Some((_, windows_new_input_path))) => {
-            input_path = windows_new_input_path;
-        }
-        _ => {}
-    }
-    if let Some((new_input_path, new_extension)) = input_path.rsplit_once('.') {
-        extension = Some(new_extension);
-        input_path = new_input_path;
-    }
-    // Then add a dash
-    let mut macro_output_path = input_path.push_str("-");
-
-    // Hash the contents along with the asset config to create a unique hash for the asset
-    // When this hash changes, the client needs to re-fetch the asset
-    let mut hasher = ConstHasher::new();
-    hasher = hasher.write(content_hash);
-    hasher = hasher.hash_by_bytes(asset_config);
-    let hash = hasher.finish();
-
-    // Then add the hash in hex form
-    let hash_bytes = hash.to_le_bytes();
-    let mut i = 0;
-    while i < hash_bytes.len() {
-        let byte = hash_bytes[i];
-        let first = byte >> 4;
-        let second = byte & 0x0f;
-        const fn byte_to_char(byte: u8) -> char {
-            match char::from_digit(byte as u32, 16) {
-                Some(c) => c,
-                None => panic!("byte must be a valid digit"),
-            }
-        }
-        macro_output_path = macro_output_path.push(byte_to_char(first));
-        macro_output_path = macro_output_path.push(byte_to_char(second));
-        i += 1;
-    }
-
-    // Finally add the extension
-    match asset_config.extension() {
-        Some(extension) => {
-            macro_output_path = macro_output_path.push('.');
-            macro_output_path = macro_output_path.push_str(extension)
-        }
-        None => {
-            if let Some(extension) = extension {
-                macro_output_path = macro_output_path.push('.');
-
-                let ext_bytes = extension.as_str().as_bytes();
-
-                // Rewrite scss as css
-                if bytes_equal(ext_bytes, b"scss") || bytes_equal(ext_bytes, b"sass") {
-                    macro_output_path = macro_output_path.push_str("css")
-                } else {
-                    macro_output_path = macro_output_path.push_str(extension.as_str())
-                }
-            }
-        }
-    }
-
-    macro_output_path
-}
-
-const fn bytes_equal(left: &[u8], right: &[u8]) -> bool {
-    if left.len() != right.len() {
-        return false;
-    }
-
-    let mut i = 0;
-    while i < left.len() {
-        if left[i] != right[i] {
-            return false;
-        }
-        i += 1;
-    }
-
-    true
-}
-
-#[test]
-fn test_unique_path() {
-    use manganis_core::{ImageAssetOptions, ImageFormat};
-    use std::path::PathBuf;
-    let mut input_path = PathBuf::from("some");
-    input_path.push("prefix");
-    input_path.push("test.png");
-    let content_hash = 123456789;
-    let asset_config = AssetOptions::Image(ImageAssetOptions::new().with_format(ImageFormat::Avif));
-    let output_path =
-        generate_unique_path(&input_path.to_string_lossy(), content_hash, &asset_config);
-    assert_eq!(output_path.as_str(), "test-603a88fe296462a3.avif");
-
-    // Changing the path without changing the contents shouldn't change the hash
-    let mut input_path = PathBuf::from("some");
-    input_path.push("prefix");
-    input_path.push("prefix");
-    input_path.push("test.png");
-    let content_hash = 123456789;
-    let asset_config = AssetOptions::Image(ImageAssetOptions::new().with_format(ImageFormat::Avif));
-    let output_path =
-        generate_unique_path(&input_path.to_string_lossy(), content_hash, &asset_config);
-    assert_eq!(output_path.as_str(), "test-603a88fe296462a3.avif");
-
-    let mut input_path = PathBuf::from("test");
-    input_path.push("ing");
-    input_path.push("test");
-    let content_hash = 123456789;
-    let asset_config = AssetOptions::Unknown;
-    let output_path =
-        generate_unique_path(&input_path.to_string_lossy(), content_hash, &asset_config);
-    assert_eq!(output_path.as_str(), "test-c8c4cfad21cac262");
-
-    // Just changing the content hash should change the total hash
-    let mut input_path = PathBuf::from("test");
-    input_path.push("ing");
-    input_path.push("test");
-    let content_hash = 123456780;
-    let asset_config = AssetOptions::Unknown;
-    let output_path =
-        generate_unique_path(&input_path.to_string_lossy(), content_hash, &asset_config);
-    assert_eq!(output_path.as_str(), "test-7bced03789ff865c");
+    create_bundled_asset(input_path, asset_config)
 }
 
 /// Serialize an asset to a const buffer

From 0bac001619eb1e1f14f3bce29a2fd8d969cf1d8c Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Mon, 14 Apr 2025 18:13:25 -0500
Subject: [PATCH 02/11] hash assets in the linker

---
 packages/cli-opt/src/css.rs                  |  38 ++++++-
 packages/cli-opt/src/file.rs                 | 109 ++++++++++++-------
 packages/cli-opt/src/hash.rs                 | 106 ++++++++++++++++++
 packages/cli-opt/src/js.rs                   |  77 ++++++++++---
 packages/cli-opt/src/lib.rs                  |  89 ++-------------
 packages/cli/src/build/bundle.rs             |   2 +-
 packages/cli/src/build/request.rs            |  26 +----
 packages/cli/src/cli/link.rs                 |  84 ++++++++++++--
 packages/manganis/manganis-core/src/asset.rs |   4 +-
 packages/manganis/manganis-core/src/hash.rs  |  94 ----------------
 packages/manganis/manganis-core/src/lib.rs   |   2 -
 11 files changed, 362 insertions(+), 269 deletions(-)
 create mode 100644 packages/cli-opt/src/hash.rs
 delete mode 100644 packages/manganis/manganis-core/src/hash.rs

diff --git a/packages/cli-opt/src/css.rs b/packages/cli-opt/src/css.rs
index 93405df376..6d64226dd2 100644
--- a/packages/cli-opt/src/css.rs
+++ b/packages/cli-opt/src/css.rs
@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::{hash::Hasher, path::Path};
 
 use anyhow::Context;
 use codemap::SpanLoc;
@@ -78,12 +78,11 @@ pub(crate) fn minify_css(css: &str) -> anyhow::Result<String> {
     Ok(res.code)
 }
 
-/// Process an scss/sass file into css.
-pub(crate) fn process_scss(
+/// Compile scss with grass
+pub(crate) fn compile_scss(
     scss_options: &CssAssetOptions,
     source: &Path,
-    output_path: &Path,
-) -> anyhow::Result<()> {
+) -> anyhow::Result<String> {
     let style = match scss_options.minified() {
         true => OutputStyle::Compressed,
         false => OutputStyle::Expanded,
@@ -94,7 +93,18 @@ pub(crate) fn process_scss(
         .quiet(false)
         .logger(&ScssLogger {});
 
-    let css = grass::from_path(source, &options)?;
+    let css = grass::from_path(source, &options)
+        .with_context(|| format!("Failed to compile scss file: {}", source.display()))?;
+    Ok(css)
+}
+
+/// Process an scss/sass file into css.
+pub(crate) fn process_scss(
+    scss_options: &CssAssetOptions,
+    source: &Path,
+    output_path: &Path,
+) -> anyhow::Result<()> {
+    let css = compile_scss(scss_options, source)?;
     let minified = minify_css(&css)?;
 
     std::fs::write(output_path, minified).with_context(|| {
@@ -131,3 +141,19 @@ impl grass::Logger for ScssLogger {
         );
     }
 }
+
+/// Hash the inputs to the scss file
+pub(crate) fn hash_scss(
+    scss_options: &CssAssetOptions,
+    source: &Path,
+    hasher: &mut impl Hasher,
+) -> anyhow::Result<()> {
+    // Grass doesn't expose the ast for us to traverse the imports in the file. Instead of parsing scss ourselves
+    // we just hash the expanded version of the file for now
+    let css = compile_scss(scss_options, source)?;
+
+    // Hash the compiled css
+    hasher.write(css.as_bytes());
+
+    Ok(())
+}
diff --git a/packages/cli-opt/src/file.rs b/packages/cli-opt/src/file.rs
index df465356cc..b038b63e7e 100644
--- a/packages/cli-opt/src/file.rs
+++ b/packages/cli-opt/src/file.rs
@@ -1,4 +1,5 @@
 use anyhow::Context;
+use manganis::FolderAssetOptions;
 use manganis_core::{AssetOptions, CssAssetOptions, ImageAssetOptions, JsAssetOptions};
 use std::path::Path;
 
@@ -47,55 +48,38 @@ pub(crate) fn process_file_to_with_options(
             .unwrap_or_default()
             .to_string_lossy()
     ));
+    let resolved_options = resolve_asset_options(source, options);
 
-    match options {
-        AssetOptions::Unknown => match source.extension().map(|e| e.to_string_lossy()).as_deref() {
-            Some("css") => {
-                process_css(&CssAssetOptions::new(), source, &temp_path)?;
-            }
-            Some("scss" | "sass") => {
-                process_scss(&CssAssetOptions::new(), source, &temp_path)?;
-            }
-            Some("js") => {
-                process_js(&JsAssetOptions::new(), source, &temp_path, !in_folder)?;
-            }
-            Some("json") => {
-                process_json(source, &temp_path)?;
-            }
-            Some("jpg" | "jpeg" | "png" | "webp" | "avif") => {
-                process_image(&ImageAssetOptions::new(), source, &temp_path)?;
-            }
-            Some(_) | None => {
-                if source.is_dir() {
-                    process_folder(source, &temp_path)?;
-                } else {
-                    let source_file = std::fs::File::open(source)?;
-                    let mut reader = std::io::BufReader::new(source_file);
-                    let output_file = std::fs::File::create(&temp_path)?;
-                    let mut writer = std::io::BufWriter::new(output_file);
-                    std::io::copy(&mut reader, &mut writer).with_context(|| {
-                        format!(
-                            "Failed to write file to output location: {}",
-                            temp_path.display()
-                        )
-                    })?;
-                }
-            }
-        },
-        AssetOptions::Css(options) => {
+    match &resolved_options {
+        ResolvedAssetType::Css(options) => {
             process_css(options, source, &temp_path)?;
         }
-        AssetOptions::Js(options) => {
+        ResolvedAssetType::Scss(options) => {
+            process_scss(options, source, &temp_path)?;
+        }
+        ResolvedAssetType::Js(options) => {
             process_js(options, source, &temp_path, !in_folder)?;
         }
-        AssetOptions::Image(options) => {
+        ResolvedAssetType::Image(options) => {
             process_image(options, source, &temp_path)?;
         }
-        AssetOptions::Folder(_) => {
+        ResolvedAssetType::Json => {
+            process_json(source, &temp_path)?;
+        }
+        ResolvedAssetType::Folder(_) => {
             process_folder(source, &temp_path)?;
         }
-        _ => {
-            tracing::warn!("Unknown asset options: {:?}", options);
+        ResolvedAssetType::File => {
+            let source_file = std::fs::File::open(source)?;
+            let mut reader = std::io::BufReader::new(source_file);
+            let output_file = std::fs::File::create(&temp_path)?;
+            let mut writer = std::io::BufWriter::new(output_file);
+            std::io::copy(&mut reader, &mut writer).with_context(|| {
+                format!(
+                    "Failed to write file to output location: {}",
+                    temp_path.display()
+                )
+            })?;
         }
     }
 
@@ -104,3 +88,48 @@ pub(crate) fn process_file_to_with_options(
 
     Ok(())
 }
+
+pub(crate) enum ResolvedAssetType {
+    /// An image asset
+    Image(ImageAssetOptions),
+    /// A css asset
+    Css(CssAssetOptions),
+    /// A SCSS asset
+    Scss(CssAssetOptions),
+    /// A javascript asset
+    Js(JsAssetOptions),
+    /// A json asset
+    Json,
+    /// A folder asset
+    Folder(FolderAssetOptions),
+    /// A generic file
+    File,
+}
+
+pub(crate) fn resolve_asset_options(source: &Path, options: &AssetOptions) -> ResolvedAssetType {
+    match options {
+        AssetOptions::Image(image) => ResolvedAssetType::Image(image.clone()),
+        AssetOptions::Css(css) => ResolvedAssetType::Css(css.clone()),
+        AssetOptions::Js(js) => ResolvedAssetType::Js(js.clone()),
+        AssetOptions::Folder(folder) => ResolvedAssetType::Folder(folder.clone()),
+        AssetOptions::Unknown => resolve_unknown_asset_options(source),
+        _ => {
+            tracing::warn!("Unknown asset options... you may need to update the Dioxus CLI. Defaulting to a generic file: {:?}", options);
+            resolve_unknown_asset_options(source)
+        }
+    }
+}
+
+fn resolve_unknown_asset_options(source: &Path) -> ResolvedAssetType {
+    match source.extension().map(|e| e.to_string_lossy()).as_deref() {
+        Some("scss" | "sass") => ResolvedAssetType::Scss(CssAssetOptions::new()),
+        Some("css") => ResolvedAssetType::Css(CssAssetOptions::new()),
+        Some("js") => ResolvedAssetType::Js(JsAssetOptions::new()),
+        Some("json") => ResolvedAssetType::Json,
+        Some("jpg" | "jpeg" | "png" | "webp" | "avif") => {
+            ResolvedAssetType::Image(ImageAssetOptions::new())
+        }
+        _ if source.is_dir() => ResolvedAssetType::Folder(FolderAssetOptions::new()),
+        _ => ResolvedAssetType::File,
+    }
+}
diff --git a/packages/cli-opt/src/hash.rs b/packages/cli-opt/src/hash.rs
new file mode 100644
index 0000000000..3561f0aa70
--- /dev/null
+++ b/packages/cli-opt/src/hash.rs
@@ -0,0 +1,106 @@
+//! Utilities for creating hashed paths to assets in Manganis. This module defines [`AssetHash`] which is used to create a hashed path to an asset in both the CLI and the macro.
+
+use std::{hash::Hasher, io::Read, path::Path};
+
+use crate::{
+    css::hash_scss,
+    file::{resolve_asset_options, ResolvedAssetType},
+    js::hash_js,
+};
+use manganis::AssetOptions;
+
+/// The opaque hash type manganis uses to identify assets. Each time an asset or asset options change, this hash will
+/// change. This hash is included in the URL of the bundled asset for cache busting.
+pub struct AssetHash {
+    /// We use a wrapper type here to hide the exact size of the hash so we can switch to a sha hash in a minor version bump
+    hash: [u8; 8],
+}
+
+impl AssetHash {
+    /// Create a new asset hash
+    const fn new(hash: u64) -> Self {
+        Self {
+            hash: hash.to_le_bytes(),
+        }
+    }
+
+    /// Get the hash bytes
+    pub const fn bytes(&self) -> &[u8] {
+        &self.hash
+    }
+
+    /// Create a new asset hash for a file. The input file to this function should be fully resolved
+    pub fn hash_file_contents(
+        options: &AssetOptions,
+        file_path: &Path,
+    ) -> anyhow::Result<AssetHash> {
+        hash_file(options, file_path)
+    }
+}
+
+/// Process a specific file asset with the given options reading from the source and writing to the output path
+fn hash_file(options: &AssetOptions, source: &Path) -> anyhow::Result<AssetHash> {
+    // Create a hasher
+    let mut hash = std::collections::hash_map::DefaultHasher::new();
+    hash_file_with_options(options, source, &mut hash, false)?;
+
+    let hash = hash.finish();
+    Ok(AssetHash::new(hash))
+}
+
+/// Process a specific file asset with additional options
+pub(crate) fn hash_file_with_options(
+    options: &AssetOptions,
+    source: &Path,
+    hasher: &mut impl Hasher,
+    in_folder: bool,
+) -> anyhow::Result<()> {
+    let resolved_options = resolve_asset_options(source, options);
+
+    match &resolved_options {
+        // Scss and JS can import files during the bundling process. We need to hash
+        // both the files themselves and any imports they have
+        ResolvedAssetType::Scss(options) => {
+            hash_scss(options, source, hasher)?;
+        }
+        ResolvedAssetType::Js(options) => {
+            hash_js(options, source, hasher, !in_folder)?;
+        }
+
+        // Otherwise, we can just hash the file contents
+        ResolvedAssetType::Css(_)
+        | ResolvedAssetType::Image(_)
+        | ResolvedAssetType::Json
+        | ResolvedAssetType::File => {
+            hash_file_contents(source, hasher)?;
+        }
+        // Or the folder contents recursively
+        ResolvedAssetType::Folder(_) => {
+            let files = std::fs::read_dir(source)?;
+            for file in files.flatten() {
+                let path = file.path();
+                hash_file_with_options(&options, &path, hasher, true)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub(crate) fn hash_file_contents(source: &Path, hasher: &mut impl Hasher) -> anyhow::Result<()> {
+    // Otherwise, open the file to get its contents
+    let mut file = std::fs::File::open(source)?;
+
+    // We add a hash to the end of the file so it is invalidated when the bundled version of the file changes
+    // The hash includes the file contents, the options, and the version of manganis. From the macro, we just
+    // know the file contents, so we only include that hash
+    let mut buffer = [0; 8192];
+    loop {
+        let read = file.read(&mut buffer)?;
+        if read == 0 {
+            break;
+        }
+        hasher.write(&buffer[..read]);
+    }
+    Ok(())
+}
diff --git a/packages/cli-opt/src/js.rs b/packages/cli-opt/src/js.rs
index d928b84b82..cf01871627 100644
--- a/packages/cli-opt/src/js.rs
+++ b/packages/cli-opt/src/js.rs
@@ -1,3 +1,4 @@
+use std::hash::Hasher;
 use std::path::Path;
 use std::path::PathBuf;
 
@@ -24,6 +25,8 @@ use swc_ecma_codegen::text_writer::JsWriter;
 use swc_ecma_loader::{resolvers::node::NodeModulesResolver, TargetEnv};
 use swc_ecma_parser::{parse_file_as_module, Syntax};
 
+use crate::hash::hash_file_contents;
+
 struct TracingEmitter;
 
 impl Emitter for TracingEmitter {
@@ -43,30 +46,32 @@ impl Emitter for TracingEmitter {
     }
 }
 
+/// Run a closure with the swc globals and handler set up
+fn inside_handler<O>(f: impl FnOnce(&Globals, Lrc<SourceMap>) -> O) -> O {
+    let globals = Globals::new();
+    let cm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+    let handler = Handler::with_emitter_and_flags(Box::new(TracingEmitter), Default::default());
+    GLOBALS.set(&globals, || HANDLER.set(&handler, || f(&globals, cm)))
+}
+
 fn bundle_js_to_writer(
     file: PathBuf,
     bundle: bool,
     minify: bool,
     write_to: &mut impl std::io::Write,
 ) -> anyhow::Result<()> {
-    let globals = Globals::new();
-    let handler = Handler::with_emitter_and_flags(Box::new(TracingEmitter), Default::default());
-    GLOBALS.set(&globals, || {
-        HANDLER.set(&handler, || {
-            bundle_js_to_writer_inside_handler(&globals, file, bundle, minify, write_to)
-        })
+    inside_handler(|globals, cm| {
+        bundle_js_to_writer_inside_handler(&globals, cm, file, bundle, minify, write_to)
     })
 }
 
-fn bundle_js_to_writer_inside_handler(
+fn resolve_js_inside_handler(
     globals: &Globals,
     file: PathBuf,
     bundle: bool,
-    minify: bool,
-    write_to: &mut impl std::io::Write,
-) -> anyhow::Result<()> {
-    let cm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
-    let mut module = if bundle {
+    cm: &Lrc<SourceMap>,
+) -> anyhow::Result<Module> {
+    if bundle {
         let node_resolver = NodeModulesResolver::new(TargetEnv::Browser, Default::default(), true);
         let mut bundler = Bundler::new(
             globals,
@@ -89,7 +94,7 @@ fn bundle_js_to_writer_inside_handler(
         let bundle = bundles
             .pop()
             .ok_or_else(|| anyhow::anyhow!("swc did not output any bundles"))?;
-        bundle.module
+        Ok(bundle.module)
     } else {
         let fm = cm.load_file(Path::new(&file)).expect("Failed to load file");
 
@@ -106,8 +111,19 @@ fn bundle_js_to_writer_inside_handler(
                 let message = err.into_diagnostic(handler).message();
                 anyhow::anyhow!("{}", message)
             })
-        })?
-    };
+        })
+    }
+}
+
+fn bundle_js_to_writer_inside_handler(
+    globals: &Globals,
+    cm: Lrc<SourceMap>,
+    file: PathBuf,
+    bundle: bool,
+    minify: bool,
+    write_to: &mut impl std::io::Write,
+) -> anyhow::Result<()> {
+    let mut module = resolve_js_inside_handler(globals, file, bundle, &cm)?;
 
     if minify {
         module = swc_ecma_minifier::optimize(
@@ -241,3 +257,34 @@ pub(crate) fn process_js(
 
     Ok(())
 }
+
+fn hash_js_module(file: PathBuf, hasher: &mut impl Hasher, bundle: bool) -> anyhow::Result<()> {
+    inside_handler(|globals, cm| {
+        _ = resolve_js_inside_handler(globals, file, bundle, &cm)?;
+
+        for file in cm.files().iter() {
+            let hash = file.src_hash;
+            hasher.write(&hash.to_le_bytes());
+        }
+
+        Ok(())
+    })
+}
+
+pub(crate) fn hash_js(
+    js_options: &JsAssetOptions,
+    source: &Path,
+    hasher: &mut impl Hasher,
+    bundle: bool,
+) -> anyhow::Result<()> {
+    if js_options.minified() {
+        if let Err(err) = hash_js_module(source.to_path_buf(), hasher, bundle) {
+            tracing::error!("Failed to minify js. Falling back to non-minified: {err}");
+            hash_file_contents(source, hasher)?;
+        }
+    } else {
+        hash_file_contents(source, hasher)?;
+    }
+
+    Ok(())
+}
diff --git a/packages/cli-opt/src/lib.rs b/packages/cli-opt/src/lib.rs
index d3d36bcc8a..b0c02faf94 100644
--- a/packages/cli-opt/src/lib.rs
+++ b/packages/cli-opt/src/lib.rs
@@ -1,8 +1,6 @@
 use anyhow::Context;
 use manganis::AssetOptions;
-use manganis_core::linker::LinkSection;
 use manganis_core::BundledAsset;
-use object::{read::archive::ArchiveFile, File as ObjectFile, Object, ObjectSection};
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
@@ -12,11 +10,13 @@ use std::sync::{Arc, RwLock};
 mod css;
 mod file;
 mod folder;
+mod hash;
 mod image;
 mod js;
 mod json;
 
 pub use file::process_file_to;
+pub use hash::AssetHash;
 
 /// A manifest of all assets collected from dependencies
 ///
@@ -48,6 +48,15 @@ impl AssetManifest {
         Ok(bundled_asset)
     }
 
+    /// Insert an existing bundled asset to the manifest
+    pub fn insert_asset(&mut self, asset: BundledAsset) {
+        let asset_path = asset.absolute_source_path();
+        self.assets
+            .entry(asset_path.into())
+            .or_default()
+            .insert(asset);
+    }
+
     /// Get any assets that are tied to a specific source file
     pub fn get_assets_for_source(&self, path: &Path) -> Option<&HashSet<BundledAsset>> {
         self.assets.get(path)
@@ -65,82 +74,6 @@ impl AssetManifest {
         serde_json::from_str(&src)
             .with_context(|| format!("Failed to parse asset manifest from {path:?}\n{src}"))
     }
-
-    /// Fill this manifest with a file object/rlib files, typically extracted from the linker intercepted
-    pub fn add_from_object_path(&mut self, path: &Path) -> anyhow::Result<()> {
-        let data = std::fs::read(path)?;
-
-        match path.extension().and_then(|ext| ext.to_str()) {
-            // Parse an rlib as a collection of objects
-            Some("rlib") => {
-                if let Ok(archive) = object::read::archive::ArchiveFile::parse(&*data) {
-                    self.add_from_archive_file(&archive, &data)?;
-                }
-            }
-            _ => {
-                if let Ok(object) = object::File::parse(&*data) {
-                    self.add_from_object_file(&object)?;
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Fill this manifest from an rlib / ar file that contains many object files and their entries
-    fn add_from_archive_file(&mut self, archive: &ArchiveFile, data: &[u8]) -> object::Result<()> {
-        // Look through each archive member for object files.
-        // Read the archive member's binary data (we know it's an object file)
-        // And parse it with the normal `object::File::parse` to find the manganis string.
-        for member in archive.members() {
-            let member = member?;
-            let name = String::from_utf8_lossy(member.name()).to_string();
-
-            // Check if the archive member is an object file and parse it.
-            if name.ends_with(".o") {
-                let data = member.data(data)?;
-                let object = object::File::parse(data)?;
-                _ = self.add_from_object_file(&object);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Fill this manifest with whatever tables might come from the object file
-    fn add_from_object_file(&mut self, obj: &ObjectFile) -> anyhow::Result<()> {
-        for section in obj.sections() {
-            let Ok(section_name) = section.name() else {
-                continue;
-            };
-
-            // Check if the link section matches the asset section for one of the platforms we support. This may not be the current platform if the user is cross compiling
-            let matches = LinkSection::ALL
-                .iter()
-                .any(|x| x.link_section == section_name);
-
-            if !matches {
-                continue;
-            }
-
-            let bytes = section
-                .uncompressed_data()
-                .context("Could not read uncompressed data from object file")?;
-
-            let mut buffer = const_serialize::ConstReadBuffer::new(&bytes);
-            while let Some((remaining_buffer, asset)) =
-                const_serialize::deserialize_const!(BundledAsset, buffer)
-            {
-                self.assets
-                    .entry(PathBuf::from(asset.absolute_source_path()))
-                    .or_default()
-                    .insert(asset);
-                buffer = remaining_buffer;
-            }
-        }
-
-        Ok(())
-    }
 }
 
 /// Optimize a list of assets in parallel
diff --git a/packages/cli/src/build/bundle.rs b/packages/cli/src/build/bundle.rs
index 7753a4efaa..37a4a28e52 100644
--- a/packages/cli/src/build/bundle.rs
+++ b/packages/cli/src/build/bundle.rs
@@ -417,7 +417,7 @@ impl AppBundle {
             return Ok(());
         }
 
-        self.clear_old_assets();
+        self.clear_old_assets().await?;
 
         let asset_dir = self.build.asset_dir();
 
diff --git a/packages/cli/src/build/request.rs b/packages/cli/src/build/request.rs
index fadb551d36..801c6514eb 100644
--- a/packages/cli/src/build/request.rs
+++ b/packages/cli/src/build/request.rs
@@ -6,11 +6,7 @@ use anyhow::Context;
 use dioxus_cli_config::{APP_TITLE_ENV, ASSET_ROOT_ENV};
 use dioxus_cli_opt::AssetManifest;
 use serde::Deserialize;
-use std::{
-    path::{Path, PathBuf},
-    process::Stdio,
-    time::Instant,
-};
+use std::{path::PathBuf, process::Stdio, time::Instant};
 use tokio::{io::AsyncBufReadExt, process::Command};
 
 #[derive(Clone, Debug)]
@@ -80,7 +76,7 @@ impl BuildRequest {
         let start = Instant::now();
         self.prepare_build_dir()?;
         let exe = self.build_cargo().await?;
-        let assets = self.collect_assets(&exe).await?;
+        let assets = self.collect_assets().await?;
 
         Ok(BuildArtifacts {
             exe,
@@ -237,26 +233,14 @@ impl BuildRequest {
     ///
     /// This uses "known paths" that have stayed relatively stable during cargo's lifetime.
     /// One day this system might break and we might need to go back to using the linker approach.
-    pub(crate) async fn collect_assets(&self, exe: &Path) -> Result<AssetManifest> {
+    pub(crate) async fn collect_assets(&self) -> Result<AssetManifest> {
         tracing::debug!("Collecting assets ...");
 
         if self.build.skip_assets {
             return Ok(AssetManifest::default());
-        }
-
-        // Experimental feature for testing - if the env var is set, we'll use the deeplinker
-        if std::env::var("DEEPLINK").is_ok() {
-            tracing::debug!("Using deeplinker instead of incremental cache");
-            return self.deep_linker_asset_extract().await;
-        }
-
-        // walk every file in the incremental cache dir, reading and inserting items into the manifest.
-        let mut manifest = AssetManifest::default();
-
-        // And then add from the exe directly, just in case it's LTO compiled and has no incremental cache
-        _ = manifest.add_from_object_path(exe);
+        };
 
-        Ok(manifest)
+        self.deep_linker_asset_extract().await
     }
 
     /// Create a list of arguments for cargo builds
diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index f063bda954..36c052d403 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -1,6 +1,8 @@
 use const_serialize::{deserialize_const, ConstVec};
+use dioxus_cli_opt::AssetManifest;
 use manganis::BundledAsset;
 use object::{Object, ObjectSection, ReadCache};
+use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 use serde::{Deserialize, Serialize};
 use std::error::Error;
 use std::fmt::Debug;
@@ -67,7 +69,7 @@ impl LinkAction {
             LinkAction::BuildAssetManifest { destination: dest } => {
                 let args: Vec<_> = std::env::args().collect();
                 let mut obj_args = args.clone();
-                let mut manifest = AssetReferences::default();
+                let mut references = AssetReferences::default();
 
                 // Handle command files, usually a windows thing.
                 if let Some(command) = args.iter().find(|arg| arg.starts_with('@')).cloned() {
@@ -102,12 +104,75 @@ impl LinkAction {
                 for item in obj_args {
                     let path_to_item = PathBuf::from(item);
                     if let Ok(path) = path_to_item.canonicalize() {
-                        _ = manifest.add_from_object_path(&path);
+                        _ = references.add_from_object_path(&path);
                     }
                 }
 
-                // let contents = serde_json::to_string(&manifest).expect("Failed to write manifest");
-                // std::fs::write(dest, contents).expect("Failed to write output file");
+                // Hash each file in parallel
+                references.assets.par_iter_mut().for_each(|asset| {
+                    match dioxus_cli_opt::AssetHash::hash_file_contents(
+                        asset.bundled_asset.options(),
+                        &asset.file,
+                    ) {
+                        Ok(hash) => {
+                            let source = asset.bundled_asset.absolute_source_path();
+                            let options = asset.bundled_asset.options().clone();
+
+                            // Set the bundled path to the source path with the hash appended before the extension
+                            let source_path = PathBuf::from(source);
+                            let Some(file_name) = source_path.file_name() else {
+                                tracing::error!("Failed to get file name from path: {source}");
+                                return;
+                            };
+                            // The output extension path is the extension set by the options
+                            // or the extension of the source file if we don't recognize the file
+                            let ext = asset
+                                .bundled_asset
+                                .options()
+                                .extension()
+                                .map(Into::into)
+                                .or_else(|| {
+                                    source_path
+                                        .extension()
+                                        .map(|ext| ext.to_string_lossy().to_string())
+                                });
+
+                            let hash = hash.bytes();
+                            let hash = hash
+                                .iter()
+                                .map(|byte| format!("{byte:x}"))
+                                .collect::<String>();
+                            let mut bundled_path =
+                                PathBuf::from(format!("/{}-{hash}", file_name.to_string_lossy()));
+
+                            if let Some(ext) = ext {
+                                bundled_path.set_extension(ext);
+                            }
+
+                            let bundled_path = bundled_path.to_string_lossy().to_string();
+
+                            asset.bundled_asset = BundledAsset::new(source, &bundled_path, options);
+
+                            // Write the contents back to the object file
+                            if let Err(err) = asset.write() {
+                                tracing::error!("Failed to write asset back to object file: {err}");
+                            }
+                        }
+                        Err(err) => {
+                            tracing::error!("Failed to hash asset: {err}");
+                        }
+                    }
+                });
+
+                // Extract the manifest from the hashed assets
+                let mut manifest = AssetManifest::default();
+                for asset in references.assets.iter() {
+                    // Add the asset to the manifest
+                    manifest.insert_asset(asset.bundled_asset);
+                }
+
+                let contents = serde_json::to_string(&manifest).expect("Failed to write manifest");
+                std::fs::write(dest, contents).expect("Failed to write output file");
 
                 // forward the modified object files to the real linker
                 let err_file = std::fs::File::options()
@@ -143,14 +208,17 @@ struct AssetReference {
 }
 
 impl AssetReference {
-    fn write(&self, new_data: &[u8]) -> std::io::Result<()> {
+    fn write(&self) -> std::io::Result<()> {
+        let new_data = ConstVec::new();
+        let new_data = const_serialize::serialize_const(&self.bundled_asset, new_data);
+
         let mut binary_data = fs::File::options()
             .write(true)
             .read(true)
             .open(&self.file)?;
         binary_data.seek(std::io::SeekFrom::Start(self.byte_span.start as u64))?;
         // Write the modified binary data back to the file
-        binary_data.write_all(&new_data)?;
+        binary_data.write_all(new_data.as_ref())?;
         binary_data.sync_all()
     }
 }
@@ -161,10 +229,6 @@ struct AssetReferences {
 }
 
 impl AssetReferences {
-    fn new() -> Self {
-        Self { assets: Vec::new() }
-    }
-
     fn add_from_object_path(&mut self, path: &PathBuf) -> Result<(), Box<dyn Error>> {
         let mut binary_data = fs::File::options().read(true).open(path)?;
         let mut range = None;
diff --git a/packages/manganis/manganis-core/src/asset.rs b/packages/manganis/manganis-core/src/asset.rs
index 72e531bd50..7851fdad49 100644
--- a/packages/manganis/manganis-core/src/asset.rs
+++ b/packages/manganis/manganis-core/src/asset.rs
@@ -33,8 +33,8 @@ impl BundledAsset {
     /// This should only be called from the macro
     /// Create a new asset
     pub const fn new(
-        absolute_source_path: &'static str,
-        bundled_path: &'static str,
+        absolute_source_path: &str,
+        bundled_path: &str,
         options: AssetOptions,
     ) -> Self {
         Self {
diff --git a/packages/manganis/manganis-core/src/hash.rs b/packages/manganis/manganis-core/src/hash.rs
deleted file mode 100644
index 3609d3d220..0000000000
--- a/packages/manganis/manganis-core/src/hash.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-//! Utilities for creating hashed paths to assets in Manganis. This module defines [`AssetHash`] which is used to create a hashed path to an asset in both the CLI and the macro.
-
-use std::{
-    error::Error,
-    hash::{Hash, Hasher},
-    io::Read,
-    path::{Path, PathBuf},
-};
-
-/// An error that can occur when hashing an asset
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum AssetHashError {
-    /// An io error occurred
-    IoError { err: std::io::Error, path: PathBuf },
-}
-
-impl std::fmt::Display for AssetHashError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            AssetHashError::IoError { path, err } => {
-                write!(f, "Failed to read file: {}; {}", path.display(), err)
-            }
-        }
-    }
-}
-
-impl Error for AssetHashError {}
-
-/// The opaque hash type manganis uses to identify assets. Each time an asset or asset options change, this hash will
-/// change. This hash is included in the URL of the bundled asset for cache busting.
-pub struct AssetHash {
-    /// We use a wrapper type here to hide the exact size of the hash so we can switch to a sha hash in a minor version bump
-    hash: [u8; 8],
-}
-
-impl AssetHash {
-    /// Create a new asset hash
-    const fn new(hash: u64) -> Self {
-        Self {
-            hash: hash.to_le_bytes(),
-        }
-    }
-
-    /// Get the hash bytes
-    pub const fn bytes(&self) -> &[u8] {
-        &self.hash
-    }
-
-    /// Create a new asset hash for a file. The input file to this function should be fully resolved
-    pub fn hash_file_contents(file_path: &Path) -> Result<AssetHash, AssetHashError> {
-        // Create a hasher
-        let mut hash = std::collections::hash_map::DefaultHasher::new();
-
-        // If this is a folder, hash the folder contents
-        if file_path.is_dir() {
-            let files = std::fs::read_dir(file_path).map_err(|err| AssetHashError::IoError {
-                err,
-                path: file_path.to_path_buf(),
-            })?;
-            for file in files.flatten() {
-                let path = file.path();
-                Self::hash_file_contents(&path)?.bytes().hash(&mut hash);
-            }
-            let hash = hash.finish();
-            return Ok(AssetHash::new(hash));
-        }
-
-        // Otherwise, open the file to get its contents
-        let mut file = std::fs::File::open(file_path).map_err(|err| AssetHashError::IoError {
-            err,
-            path: file_path.to_path_buf(),
-        })?;
-
-        // We add a hash to the end of the file so it is invalidated when the bundled version of the file changes
-        // The hash includes the file contents, the options, and the version of manganis. From the macro, we just
-        // know the file contents, so we only include that hash
-        let mut buffer = [0; 8192];
-        loop {
-            let read = file
-                .read(&mut buffer)
-                .map_err(|err| AssetHashError::IoError {
-                    err,
-                    path: file_path.to_path_buf(),
-                })?;
-            if read == 0 {
-                break;
-            }
-            hash.write(&buffer[..read]);
-        }
-
-        Ok(AssetHash::new(hash.finish()))
-    }
-}
diff --git a/packages/manganis/manganis-core/src/lib.rs b/packages/manganis/manganis-core/src/lib.rs
index 52e6ac80b2..b3dddf836b 100644
--- a/packages/manganis/manganis-core/src/lib.rs
+++ b/packages/manganis/manganis-core/src/lib.rs
@@ -17,5 +17,3 @@ mod asset;
 pub use asset::*;
 
 pub mod linker;
-
-pub mod hash;

From 2e1292f3d31ce109612635c77139f70439aa5df7 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Tue, 15 Apr 2025 19:15:24 -0500
Subject: [PATCH 03/11] fix extracting assets

---
 packages/cli-opt/src/lib.rs       |   1 -
 packages/cli/src/build/request.rs | 104 +++++++++---------------------
 packages/cli/src/cli/link.rs      |  43 ++++++++----
 3 files changed, 62 insertions(+), 86 deletions(-)

diff --git a/packages/cli-opt/src/lib.rs b/packages/cli-opt/src/lib.rs
index b0c02faf94..a088311e6f 100644
--- a/packages/cli-opt/src/lib.rs
+++ b/packages/cli-opt/src/lib.rs
@@ -67,7 +67,6 @@ impl AssetManifest {
         self.assets.values().flat_map(|assets| assets.iter())
     }
 
-    #[allow(dead_code)]
     pub fn load_from_file(path: &Path) -> anyhow::Result<Self> {
         let src = std::fs::read_to_string(path)?;
 
diff --git a/packages/cli/src/build/request.rs b/packages/cli/src/build/request.rs
index 801c6514eb..872e0d88bd 100644
--- a/packages/cli/src/build/request.rs
+++ b/packages/cli/src/build/request.rs
@@ -75,8 +75,7 @@ impl BuildRequest {
 
         let start = Instant::now();
         self.prepare_build_dir()?;
-        let exe = self.build_cargo().await?;
-        let assets = self.collect_assets().await?;
+        let (exe, assets) = self.build_cargo().await?;
 
         Ok(BuildArtifacts {
             exe,
@@ -100,7 +99,7 @@ impl BuildRequest {
     /// Run `cargo`, returning the location of the final executable
     ///
     /// todo: add some stats here, like timing reports, crate-graph optimizations, etc
-    pub(crate) async fn build_cargo(&self) -> Result<PathBuf> {
+    pub(crate) async fn build_cargo(&self) -> Result<(PathBuf, AssetManifest)> {
         tracing::debug!("Executing cargo...");
 
         // Extract the unit count of the crate graph so build_cargo has more accurate data
@@ -111,12 +110,27 @@ impl BuildRequest {
 
         let mut cmd = Command::new("cargo");
 
+        // Create a temp file to put the output of the args
+        // We need to do this since rustc won't actually print the link args to stdout, so we need to
+        // give `dx` a file to dump its env::args into
+        let out_file = self.root_dir().join("linker_args.json");
+
+        // Run rustc with a custom linker (dx) and an env var to force `dx` to act as a linker
+        //
+        // This will force `dx` to look through the incremental cache and find the assets from the previous build
         cmd.arg("rustc")
             .current_dir(self.krate.crate_dir())
             .arg("--message-format")
             .arg("json-diagnostic-rendered-ansi")
             .args(self.build_arguments())
-            .envs(self.env_vars()?);
+            .envs(self.env_vars()?)
+            .env(
+                LinkAction::ENV_VAR_NAME,
+                LinkAction::BuildAssetManifest {
+                    destination: out_file.clone(),
+                }
+                .to_json(),
+            );
 
         if let Some(target_dir) = self.custom_target_dir.as_ref() {
             cmd.env("CARGO_TARGET_DIR", target_dir);
@@ -226,21 +240,10 @@ impl BuildRequest {
             out_location
         );
 
-        Ok(out_location)
-    }
-
-    /// Traverse the target directory and collect all assets from the incremental cache
-    ///
-    /// This uses "known paths" that have stayed relatively stable during cargo's lifetime.
-    /// One day this system might break and we might need to go back to using the linker approach.
-    pub(crate) async fn collect_assets(&self) -> Result<AssetManifest> {
-        tracing::debug!("Collecting assets ...");
-
-        if self.build.skip_assets {
-            return Ok(AssetManifest::default());
-        };
+        // The linker wrote the manifest to the temp file, let's load it!
+        let manifest = AssetManifest::load_from_file(&out_file)?;
 
-        self.deep_linker_asset_extract().await
+        Ok((out_location, manifest))
     }
 
     /// Create a list of arguments for cargo builds
@@ -330,11 +333,21 @@ impl BuildRequest {
 
         cargo_args.push(self.krate.executable_name().to_string());
 
+        cargo_args.push("--".to_string());
+
+        cargo_args.push(format!(
+            "-Clinker={}",
+            std::env::current_exe()
+                .unwrap()
+                .canonicalize()
+                .unwrap()
+                .display()
+        ));
+
         // the bundle splitter needs relocation data
         // we'll trim these out if we don't need them during the bundling process
         // todo(jon): for wasm binary patching we might want to leave these on all the time.
         if self.build.platform() == Platform::Web && self.build.experimental_wasm_split {
-            cargo_args.push("--".to_string());
             cargo_args.push("-Clink-args=--emit-relocs".to_string());
         }
 
@@ -343,7 +356,6 @@ impl BuildRequest {
         cargo_args
     }
 
-    #[allow(dead_code)]
     pub(crate) fn android_rust_flags(&self) -> String {
         let mut rust_flags = std::env::var("RUSTFLAGS").unwrap_or_default();
 
@@ -441,58 +453,6 @@ impl BuildRequest {
         })
     }
 
-    /// We used to require traversing incremental artifacts for assets that were included but not
-    /// directly exposed to the final binary. Now, however, we force APIs to carry items created
-    /// from asset calls into top-level items such that they *do* get included in the final binary.
-    ///
-    /// There's a chance that's not actually true, so this function is kept around in case we do
-    /// need to revert to "deep extraction".
-    async fn deep_linker_asset_extract(&self) -> Result<AssetManifest> {
-        // Create a temp file to put the output of the args
-        // We need to do this since rustc won't actually print the link args to stdout, so we need to
-        // give `dx` a file to dump its env::args into
-        let tmp_file = tempfile::NamedTempFile::new()?;
-
-        // Run `cargo rustc` again, but this time with a custom linker (dx) and an env var to force
-        // `dx` to act as a linker
-        //
-        // This will force `dx` to look through the incremental cache and find the assets from the previous build
-        Command::new("cargo")
-            .arg("rustc")
-            .args(self.build_arguments())
-            .envs(self.env_vars()?)
-            .arg("--offline") /* don't use the network, should already be resolved */
-            .arg("--")
-            .arg(format!(
-                "-Clinker={}",
-                std::env::current_exe()
-                    .unwrap()
-                    .canonicalize()
-                    .unwrap()
-                    .display()
-            ))
-            .env(
-                LinkAction::ENV_VAR_NAME,
-                LinkAction::BuildAssetManifest {
-                    destination: tmp_file.path().to_path_buf().clone(),
-                }
-                .to_json(),
-            )
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .output()
-            .await?;
-
-        // The linker wrote the manifest to the temp file, let's load it!
-        let manifest = AssetManifest::load_from_file(tmp_file.path())?;
-
-        if let Ok(path) = std::env::var("DEEPLINK").map(|s| s.parse::<PathBuf>().unwrap()) {
-            _ = tmp_file.persist(path);
-        }
-
-        Ok(manifest)
-    }
-
     fn env_vars(&self) -> Result<Vec<(&str, String)>> {
         let mut env_vars = vec![];
 
diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index 36c052d403..752617aa5e 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -1,4 +1,4 @@
-use const_serialize::{deserialize_const, ConstVec};
+use const_serialize::ConstVec;
 use dioxus_cli_opt::AssetManifest;
 use manganis::BundledAsset;
 use object::{Object, ObjectSection, ReadCache};
@@ -50,6 +50,18 @@ impl LinkAction {
     /// hmmmmmmmm tbh I'd rather just pass the object files back and do the parsing here, but the interface
     /// is nicer to just bounce back the args and let the host do the parsing/canonicalization
     pub(crate) fn run(self) {
+        let log_file = std::fs::File::options()
+            .append(true)
+            .create(true)
+            .open("/Users/evanalmloff/Desktop/Github/dioxus-test/linker_logs.txt")
+            .unwrap();
+        tracing_subscriber::fmt()
+            .with_writer(log_file)
+            .with_max_level(tracing::Level::DEBUG)
+            .compact()
+            .with_ansi(false)
+            .init();
+
         match self {
             // Literally just run the android linker :)
             LinkAction::LinkAndroid {
@@ -172,6 +184,7 @@ impl LinkAction {
                 }
 
                 let contents = serde_json::to_string(&manifest).expect("Failed to write manifest");
+                tracing::info!("Writing asset manifest to {}", dest.display());
                 std::fs::write(dest, contents).expect("Failed to write output file");
 
                 // forward the modified object files to the real linker
@@ -253,18 +266,22 @@ impl AssetReferences {
             binary_data.seek(std::io::SeekFrom::Start(range.start as u64))?;
             let mut data_in_range = vec![0; range.len()];
             binary_data.read_exact(&mut data_in_range)?;
-            for offset in (0..data_in_range.len()).step_by(std::mem::size_of::<BundledAsset>()) {
-                let range = (range.start + offset)
-                    ..(range.start + offset + std::mem::size_of::<BundledAsset>());
-                let const_vec = ConstVec::new().extend(&data_in_range[range.clone()]);
-                if let Some((_, bundled_asset)) = deserialize_const!(BundledAsset, const_vec.read())
-                {
-                    self.assets.push(AssetReference {
-                        file: path.clone(),
-                        byte_span: range,
-                        bundled_asset,
-                    });
-                }
+            let mut offset = 0;
+            tracing::info!("Found {} bytes of data in range", data_in_range.len());
+            let mut buffer = const_serialize::ConstReadBuffer::new(&data_in_range);
+
+            while let Some((remaining_buffer, bundled_asset)) =
+                const_serialize::deserialize_const!(BundledAsset, buffer)
+            {
+                let end = data_in_range.len() - remaining_buffer.as_ref().len();
+                let range = (range.start + offset)..(range.start + end);
+                self.assets.push(AssetReference {
+                    file: path.clone(),
+                    byte_span: range,
+                    bundled_asset,
+                });
+                offset = end;
+                buffer = remaining_buffer;
             }
         }
         Ok(())

From 1d4faf7fee246da423ef9fd014b12f0312ca2e9e Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Tue, 15 Apr 2025 19:28:25 -0500
Subject: [PATCH 04/11] Fix the hashed asset name

---
 packages/cli-opt/src/file.rs      |  4 ++--
 packages/cli-opt/src/image/mod.rs | 35 ++++++++++++++++++++-----------
 packages/cli/src/cli/link.rs      |  9 ++++++--
 3 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/packages/cli-opt/src/file.rs b/packages/cli-opt/src/file.rs
index b038b63e7e..3010cf6dc0 100644
--- a/packages/cli-opt/src/file.rs
+++ b/packages/cli-opt/src/file.rs
@@ -34,7 +34,7 @@ pub(crate) fn process_file_to_with_options(
     }
     if let Some(parent) = output_path.parent() {
         if !parent.exists() {
-            std::fs::create_dir_all(parent)?;
+            std::fs::create_dir_all(parent).context("Failed to create directory")?;
         }
     }
 
@@ -84,7 +84,7 @@ pub(crate) fn process_file_to_with_options(
     }
 
     // If everything was successful, rename the temp file to the final output path
-    std::fs::rename(temp_path, output_path)?;
+    std::fs::rename(temp_path, output_path).context("Failed to rename output file")?;
 
     Ok(())
 }
diff --git a/packages/cli-opt/src/image/mod.rs b/packages/cli-opt/src/image/mod.rs
index 4ab0087ae5..515079f643 100644
--- a/packages/cli-opt/src/image/mod.rs
+++ b/packages/cli-opt/src/image/mod.rs
@@ -14,7 +14,8 @@ pub(crate) fn process_image(
     output_path: &Path,
 ) -> anyhow::Result<()> {
     let mut image = image::ImageReader::new(std::io::Cursor::new(&*std::fs::read(source)?))
-        .with_guessed_format()?
+        .with_guessed_format()
+        .context("Failed to guess image format")?
         .decode();
 
     if let Ok(image) = &mut image {
@@ -25,10 +26,10 @@ pub(crate) fn process_image(
 
     match (image, image_options.format()) {
         (image, ImageFormat::Png) => {
-            compress_png(image?, output_path);
+            compress_png(image.context("Failed to decode image")?, output_path);
         }
         (image, ImageFormat::Jpg) => {
-            compress_jpg(image?, output_path)?;
+            compress_jpg(image.context("Failed to decode image")?, output_path)?;
         }
         (Ok(image), ImageFormat::Avif) => {
             if let Err(error) = image.save(output_path) {
@@ -41,20 +42,30 @@ pub(crate) fn process_image(
             }
         }
         (Ok(image), _) => {
-            image.save(output_path)?;
+            image.save(output_path).with_context(|| {
+                format!(
+                    "Failed to save image (from {}) with path {}",
+                    source.display(),
+                    output_path.display()
+                )
+            })?;
         }
         // If we can't decode the image or it is of an unknown type, we just copy the file
         _ => {
-            let source_file = std::fs::File::open(source)?;
+            let source_file = std::fs::File::open(source).context("Failed to open source file")?;
             let mut reader = std::io::BufReader::new(source_file);
-            let output_file = std::fs::File::create(output_path)?;
-            let mut writer = std::io::BufWriter::new(output_file);
-            std::io::copy(&mut reader, &mut writer).with_context(|| {
-                format!(
-                    "Failed to write image to output location: {}",
-                    output_path.display()
-                )
+            let output_file = std::fs::File::create(output_path).with_context(|| {
+                format!("Failed to create output file: {}", output_path.display())
             })?;
+            let mut writer = std::io::BufWriter::new(output_file);
+            std::io::copy(&mut reader, &mut writer)
+                .with_context(|| {
+                    format!(
+                        "Failed to write image to output location: {}",
+                        output_path.display()
+                    )
+                })
+                .context("Failed to copy image data")?;
         }
     }
 
diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index 752617aa5e..1f09eecdcb 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -138,7 +138,7 @@ impl LinkAction {
                             };
                             // The output extension path is the extension set by the options
                             // or the extension of the source file if we don't recognize the file
-                            let ext = asset
+                            let mut ext = asset
                                 .bundled_asset
                                 .options()
                                 .extension()
@@ -149,13 +149,18 @@ impl LinkAction {
                                         .map(|ext| ext.to_string_lossy().to_string())
                                 });
 
+                            // Rewrite scss as css
+                            if let Some("scss" | "sass") = ext.as_deref() {
+                                ext = Some("css".to_string());
+                            }
+
                             let hash = hash.bytes();
                             let hash = hash
                                 .iter()
                                 .map(|byte| format!("{byte:x}"))
                                 .collect::<String>();
                             let mut bundled_path =
-                                PathBuf::from(format!("/{}-{hash}", file_name.to_string_lossy()));
+                                PathBuf::from(format!("{}-{hash}", file_name.to_string_lossy()));
 
                             if let Some(ext) = ext {
                                 bundled_path.set_extension(ext);

From e3468a6b07ebabe9440653c588993af2b2495f81 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Tue, 15 Apr 2025 20:02:37 -0500
Subject: [PATCH 05/11] deserialize the asset back from the link section

---
 packages/cli/src/cli/link.rs                  | 26 ++++++++++++-------
 packages/const-serialize/src/const_buffers.rs |  5 ++++
 packages/manganis/manganis-core/src/asset.rs  | 12 ++-------
 packages/manganis/manganis-macro/src/asset.rs |  4 ++-
 .../manganis/manganis-macro/src/linker.rs     |  5 ----
 .../manganis/manganis/src/macro_helpers.rs    |  9 +++++++
 6 files changed, 36 insertions(+), 25 deletions(-)

diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index 1f09eecdcb..a21976453f 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -8,7 +8,6 @@ use std::error::Error;
 use std::fmt::Debug;
 use std::fs;
 use std::io::{Read, Seek, Write};
-use std::ops::Range;
 use std::path::PathBuf;
 use std::process::Command;
 use target_lexicon::Triple;
@@ -159,8 +158,9 @@ impl LinkAction {
                                 .iter()
                                 .map(|byte| format!("{byte:x}"))
                                 .collect::<String>();
+                            let file_stem = source_path.file_stem().unwrap_or(file_name);
                             let mut bundled_path =
-                                PathBuf::from(format!("{}-{hash}", file_name.to_string_lossy()));
+                                PathBuf::from(format!("{}-{hash}", file_stem.to_string_lossy()));
 
                             if let Some(ext) = ext {
                                 bundled_path.set_extension(ext);
@@ -221,7 +221,7 @@ impl LinkAction {
 
 struct AssetReference {
     file: PathBuf,
-    byte_span: Range<usize>,
+    offset: usize,
     bundled_asset: BundledAsset,
 }
 
@@ -229,15 +229,24 @@ impl AssetReference {
     fn write(&self) -> std::io::Result<()> {
         let new_data = ConstVec::new();
         let new_data = const_serialize::serialize_const(&self.bundled_asset, new_data);
+        tracing::info!(
+            "Writing {} bytes to {} at offset {}",
+            new_data.len(),
+            self.file.display(),
+            self.offset
+        );
+        tracing::info!("data {:?}", self.bundled_asset);
 
         let mut binary_data = fs::File::options()
             .write(true)
             .read(true)
             .open(&self.file)?;
-        binary_data.seek(std::io::SeekFrom::Start(self.byte_span.start as u64))?;
+        binary_data.seek(std::io::SeekFrom::Start(self.offset as u64))?;
         // Write the modified binary data back to the file
         binary_data.write_all(new_data.as_ref())?;
-        binary_data.sync_all()
+        binary_data.sync_all()?;
+
+        Ok(())
     }
 }
 
@@ -278,14 +287,13 @@ impl AssetReferences {
             while let Some((remaining_buffer, bundled_asset)) =
                 const_serialize::deserialize_const!(BundledAsset, buffer)
             {
-                let end = data_in_range.len() - remaining_buffer.as_ref().len();
-                let range = (range.start + offset)..(range.start + end);
+                let len = (data_in_range.len() - remaining_buffer.remaining().len()) - offset;
                 self.assets.push(AssetReference {
                     file: path.clone(),
-                    byte_span: range,
+                    offset: range.start + offset,
                     bundled_asset,
                 });
-                offset = end;
+                offset += len;
                 buffer = remaining_buffer;
             }
         }
diff --git a/packages/const-serialize/src/const_buffers.rs b/packages/const-serialize/src/const_buffers.rs
index c230a6d8aa..4e93ddbdbc 100644
--- a/packages/const-serialize/src/const_buffers.rs
+++ b/packages/const-serialize/src/const_buffers.rs
@@ -30,4 +30,9 @@ impl<'a> ConstReadBuffer<'a> {
     pub const fn as_ref(&self) -> &[u8] {
         self.memory
     }
+
+    /// Get a slice of the buffer from the current location to the end of the buffer
+    pub const fn remaining(&self) -> &[u8] {
+        self.memory.split_at(self.location).1
+    }
 }
diff --git a/packages/manganis/manganis-core/src/asset.rs b/packages/manganis/manganis-core/src/asset.rs
index 7851fdad49..6366f661cd 100644
--- a/packages/manganis/manganis-core/src/asset.rs
+++ b/packages/manganis/manganis-core/src/asset.rs
@@ -106,19 +106,14 @@ impl BundledAsset {
 pub struct Asset {
     /// The bundled asset
     bundled: BundledAsset,
-    /// The link section for the asset
-    keep_link_section: fn() -> u8,
 }
 
 impl Asset {
     #[doc(hidden)]
     /// This should only be called from the macro
     /// Create a new asset from the bundled form of the asset and the link section
-    pub const fn new(bundled: BundledAsset, keep_link_section: fn() -> u8) -> Self {
-        Self {
-            bundled,
-            keep_link_section,
-        }
+    pub const fn new(bundled: BundledAsset) -> Self {
+        Self { bundled }
     }
 
     /// Get the bundled asset
@@ -131,9 +126,6 @@ impl Asset {
     /// Attempts to resolve it against an `assets` folder in the current directory.
     /// If that doesn't exist, it will resolve against the cargo manifest dir
     pub fn resolve(&self) -> PathBuf {
-        // Force a volatile read of the asset link section to ensure the symbol makes it into the binary
-        (self.keep_link_section)();
-
         #[cfg(feature = "dioxus")]
         // If the asset is relative, we resolve the asset at the current directory
         if !dioxus_core_types::is_bundled_app() {
diff --git a/packages/manganis/manganis-macro/src/asset.rs b/packages/manganis/manganis-macro/src/asset.rs
index 0cd323b5f3..382e621e39 100644
--- a/packages/manganis/manganis-macro/src/asset.rs
+++ b/packages/manganis/manganis-macro/src/asset.rs
@@ -171,7 +171,9 @@ impl ToTokens for AssetParser {
 
                 #link_section
 
-                manganis::Asset::new(__ASSET, __keep_link_section)
+                manganis::Asset::new(
+                    manganis::macro_helpers::deserialize_asset(&__LINK_SECTION)
+                )
             }
         })
     }
diff --git a/packages/manganis/manganis-macro/src/linker.rs b/packages/manganis/manganis-macro/src/linker.rs
index 42fad42011..25471e4c3f 100644
--- a/packages/manganis/manganis-macro/src/linker.rs
+++ b/packages/manganis/manganis-macro/src/linker.rs
@@ -23,11 +23,6 @@ pub fn generate_link_section(asset: impl ToTokens) -> TokenStream2 {
 
         // Now that we have the size of the asset, copy the bytes into a static array
         #[link_section = #section_name]
-        #[used]
         static __LINK_SECTION: [u8; __LEN] = manganis::macro_helpers::copy_bytes(__BYTES);
-
-        fn __keep_link_section() -> u8 {
-            unsafe { std::ptr::read_volatile(__LINK_SECTION.as_ptr()) }
-        }
     }
 }
diff --git a/packages/manganis/manganis/src/macro_helpers.rs b/packages/manganis/manganis/src/macro_helpers.rs
index 6cad5a2801..c6a19bcdad 100644
--- a/packages/manganis/manganis/src/macro_helpers.rs
+++ b/packages/manganis/manganis/src/macro_helpers.rs
@@ -29,6 +29,15 @@ pub const fn serialize_asset(asset: &BundledAsset) -> ConstVec<u8> {
     serialize_const(asset, write)
 }
 
+/// Deserialize a const buffer into a BundledAsset
+pub const fn deserialize_asset(bytes: &[u8]) -> BundledAsset {
+    let bytes = ConstVec::new().extend(bytes);
+    match const_serialize::deserialize_const!(BundledAsset, bytes.read()) {
+        Some((_, asset)) => asset,
+        None => panic!("Failed to deserialize asset. This may be caused by a mismatch between your dioxus and dioxus-cli versions"),
+    }
+}
+
 /// Copy a slice into a constant sized buffer at compile time
 pub const fn copy_bytes<const N: usize>(bytes: &[u8]) -> [u8; N] {
     let mut out = [0; N];

From 1cee44e7c55b8ef482840f33d479e16eac24389a Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Wed, 16 Apr 2025 09:39:29 -0500
Subject: [PATCH 06/11] prevent the read from being inlined

---
 packages/cli/src/cli/link.rs                  | 23 +++++++++-------
 packages/manganis/manganis-core/src/asset.rs  | 27 +++++++++++++------
 packages/manganis/manganis-macro/src/asset.rs |  4 ++-
 3 files changed, 36 insertions(+), 18 deletions(-)

diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index a21976453f..0f1fe34092 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -263,16 +263,21 @@ impl AssetReferences {
             let read_cache = ReadCache::new(&mut binary_data);
             let file = object::File::parse(&read_cache)?;
             for section in file.sections() {
-                if section.name()? == "manganis" && section.segment_name()? == Some("__DATA") {
-                    if file.format() == object::BinaryFormat::Wasm {
-                        // In wasm this is actually the start and end
-                        let (start, end) = section.file_range().unwrap();
-                        range = Some(start as usize..end as usize);
-                    } else {
-                        let (offset, len) = section.file_range().unwrap();
-                        range = Some(offset as usize..(offset + len) as usize);
+                if let Ok(name) = section.name() {
+                    if manganis_core::linker::LinkSection::ALL
+                        .iter()
+                        .any(|section| section.name == name)
+                    {
+                        if file.format() == object::BinaryFormat::Wasm {
+                            // In wasm this is actually the start and end
+                            let (start, end) = section.file_range().unwrap();
+                            range = Some(start as usize..end as usize);
+                        } else {
+                            let (offset, len) = section.file_range().unwrap();
+                            range = Some(offset as usize..(offset + len) as usize);
+                        }
+                        break;
                     }
-                    break;
                 }
             }
         }
diff --git a/packages/manganis/manganis-core/src/asset.rs b/packages/manganis/manganis-core/src/asset.rs
index 6366f661cd..d7db23be70 100644
--- a/packages/manganis/manganis-core/src/asset.rs
+++ b/packages/manganis/manganis-core/src/asset.rs
@@ -1,5 +1,5 @@
 use crate::AssetOptions;
-use const_serialize::{ConstStr, SerializeConst};
+use const_serialize::{deserialize_const, ConstStr, ConstVec, SerializeConst};
 use std::path::PathBuf;
 
 /// An asset that should be copied by the bundler with some options. This type will be
@@ -104,21 +104,32 @@ impl BundledAsset {
 /// ```
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub struct Asset {
-    /// The bundled asset
-    bundled: BundledAsset,
+    /// A pointer to the bundled asset. This will be resolved after the linker has run and
+    /// put into the lazy asset
+    bundled: *const [u8],
 }
 
+unsafe impl Send for Asset {}
+unsafe impl Sync for Asset {}
+
 impl Asset {
     #[doc(hidden)]
     /// This should only be called from the macro
     /// Create a new asset from the bundled form of the asset and the link section
-    pub const fn new(bundled: BundledAsset) -> Self {
+    pub const fn new(bundled: *const [u8]) -> Self {
         Self { bundled }
     }
 
     /// Get the bundled asset
-    pub const fn bundled(&self) -> &BundledAsset {
-        &self.bundled
+    pub fn bundled(&self) -> BundledAsset {
+        let len = self.bundled.len();
+        let ptr = self.bundled as *const u8;
+        let mut bytes = ConstVec::new();
+        for byte in 0..len {
+            bytes = bytes.push(unsafe { std::ptr::read_volatile(ptr.add(byte)) });
+        }
+        let read = bytes.read();
+        deserialize_const!(BundledAsset, read).unwrap().1
     }
 
     /// Return a canonicalized path to the asset
@@ -129,7 +140,7 @@ impl Asset {
         #[cfg(feature = "dioxus")]
         // If the asset is relative, we resolve the asset at the current directory
         if !dioxus_core_types::is_bundled_app() {
-            return PathBuf::from(self.bundled.absolute_source_path.as_str());
+            return PathBuf::from(self.bundled().absolute_source_path.as_str());
         }
 
         #[cfg(feature = "dioxus")]
@@ -149,7 +160,7 @@ impl Asset {
 
         // Otherwise presumably we're bundled and we can use the bundled path
         bundle_root.join(PathBuf::from(
-            self.bundled.bundled_path.as_str().trim_start_matches('/'),
+            self.bundled().bundled_path.as_str().trim_start_matches('/'),
         ))
     }
 }
diff --git a/packages/manganis/manganis-macro/src/asset.rs b/packages/manganis/manganis-macro/src/asset.rs
index 382e621e39..79bf3f968f 100644
--- a/packages/manganis/manganis-macro/src/asset.rs
+++ b/packages/manganis/manganis-macro/src/asset.rs
@@ -171,8 +171,10 @@ impl ToTokens for AssetParser {
 
                 #link_section
 
+                static __REFERENCE_TO_LINK_SECTION: &'static [u8] = &__LINK_SECTION;
+
                 manganis::Asset::new(
-                    manganis::macro_helpers::deserialize_asset(&__LINK_SECTION)
+                    __REFERENCE_TO_LINK_SECTION as *const [u8]
                 )
             }
         })

From 60a9da0700e6e77a570dbc3cc28644a6f7d40993 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Wed, 16 Apr 2025 09:41:54 -0500
Subject: [PATCH 07/11] remove some extra logs

---
 packages/cli/src/cli/link.rs | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index 0f1fe34092..de2f9101ab 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -189,7 +189,6 @@ impl LinkAction {
                 }
 
                 let contents = serde_json::to_string(&manifest).expect("Failed to write manifest");
-                tracing::info!("Writing asset manifest to {}", dest.display());
                 std::fs::write(dest, contents).expect("Failed to write output file");
 
                 // forward the modified object files to the real linker
@@ -229,13 +228,6 @@ impl AssetReference {
     fn write(&self) -> std::io::Result<()> {
         let new_data = ConstVec::new();
         let new_data = const_serialize::serialize_const(&self.bundled_asset, new_data);
-        tracing::info!(
-            "Writing {} bytes to {} at offset {}",
-            new_data.len(),
-            self.file.display(),
-            self.offset
-        );
-        tracing::info!("data {:?}", self.bundled_asset);
 
         let mut binary_data = fs::File::options()
             .write(true)
@@ -286,7 +278,6 @@ impl AssetReferences {
             let mut data_in_range = vec![0; range.len()];
             binary_data.read_exact(&mut data_in_range)?;
             let mut offset = 0;
-            tracing::info!("Found {} bytes of data in range", data_in_range.len());
             let mut buffer = const_serialize::ConstReadBuffer::new(&data_in_range);
 
             while let Some((remaining_buffer, bundled_asset)) =

From bc858bdaa7b1936d6453442ba71cefc5af009741 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Tue, 29 Apr 2025 17:25:28 -0500
Subject: [PATCH 08/11] On wasm, create a new object file with the asset
 information

---
 Cargo.lock                                    |  30 +++-
 packages/cli-opt/src/hash.rs                  |  62 +++++++-
 packages/cli-opt/src/lib.rs                   |   6 +-
 packages/cli/Cargo.toml                       |   1 +
 packages/cli/src/cli/link.rs                  | 149 +++++++++++-------
 packages/manganis/manganis-core/src/asset.rs  |  25 ++-
 packages/manganis/manganis-macro/src/asset.rs |  24 ++-
 .../manganis/manganis-macro/src/linker.rs     |   9 +-
 .../manganis/manganis/src/macro_helpers.rs    |  16 +-
 9 files changed, 241 insertions(+), 81 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ce6a7095d3..bfcea341c0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3618,6 +3618,7 @@ dependencies = [
  "unicode-segmentation",
  "uuid",
  "walkdir",
+ "wasm-encoder 0.229.0",
  "wasm-opt",
  "wasm-split-cli",
  "which 7.0.2",
@@ -7810,6 +7811,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
 [[package]]
 name = "lebe"
 version = "0.5.2"
@@ -15206,7 +15213,7 @@ dependencies = [
  "log",
  "rayon",
  "walrus-macro",
- "wasm-encoder",
+ "wasm-encoder 0.214.0",
  "wasmparser 0.214.0",
 ]
 
@@ -15384,6 +15391,16 @@ dependencies = [
  "leb128",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.229.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38ba1d491ecacb085a2552025c10a675a6fddcbd03b1fc9b36c536010ce265d2"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.229.0",
+]
+
 [[package]]
 name = "wasm-opt"
 version = "0.116.1"
@@ -15536,6 +15553,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "wasmparser"
+version = "0.229.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc3b1f053f5d41aa55640a1fa9b6d1b8a9e4418d118ce308d20e24ff3575a8c"
+dependencies = [
+ "bitflags 2.9.0",
+ "indexmap 2.9.0",
+ "semver 1.0.26",
+]
+
 [[package]]
 name = "wayland-backend"
 version = "0.3.8"
diff --git a/packages/cli-opt/src/hash.rs b/packages/cli-opt/src/hash.rs
index 3561f0aa70..2fc8e080dc 100644
--- a/packages/cli-opt/src/hash.rs
+++ b/packages/cli-opt/src/hash.rs
@@ -1,17 +1,21 @@
 //! Utilities for creating hashed paths to assets in Manganis. This module defines [`AssetHash`] which is used to create a hashed path to an asset in both the CLI and the macro.
 
-use std::{hash::Hasher, io::Read, path::Path};
+use std::{
+    hash::Hasher,
+    io::Read,
+    path::{Path, PathBuf},
+};
 
 use crate::{
     css::hash_scss,
     file::{resolve_asset_options, ResolvedAssetType},
     js::hash_js,
 };
-use manganis::AssetOptions;
+use manganis::{AssetOptions, BundledAsset};
 
 /// The opaque hash type manganis uses to identify assets. Each time an asset or asset options change, this hash will
 /// change. This hash is included in the URL of the bundled asset for cache busting.
-pub struct AssetHash {
+struct AssetHash {
     /// We use a wrapper type here to hide the exact size of the hash so we can switch to a sha hash in a minor version bump
     hash: [u8; 8],
 }
@@ -32,9 +36,9 @@ impl AssetHash {
     /// Create a new asset hash for a file. The input file to this function should be fully resolved
     pub fn hash_file_contents(
         options: &AssetOptions,
-        file_path: &Path,
+        file_path: impl AsRef<Path>,
     ) -> anyhow::Result<AssetHash> {
-        hash_file(options, file_path)
+        hash_file(options, file_path.as_ref())
     }
 }
 
@@ -104,3 +108,51 @@ pub(crate) fn hash_file_contents(source: &Path, hasher: &mut impl Hasher) -> any
     }
     Ok(())
 }
+
+/// Add a hash to the asset, or log an error if it fails
+pub fn add_hash_to_asset(asset: &mut BundledAsset) {
+    let source = asset.absolute_source_path();
+    match AssetHash::hash_file_contents(asset.options(), &source) {
+        Ok(hash) => {
+            let options = asset.options().clone();
+
+            // Set the bundled path to the source path with the hash appended before the extension
+            let source_path = PathBuf::from(source);
+            let Some(file_name) = source_path.file_name() else {
+                tracing::error!("Failed to get file name from path: {source}");
+                return;
+            };
+            // The output extension path is the extension set by the options
+            // or the extension of the source file if we don't recognize the file
+            let mut ext = asset.options().extension().map(Into::into).or_else(|| {
+                source_path
+                    .extension()
+                    .map(|ext| ext.to_string_lossy().to_string())
+            });
+
+            // Rewrite scss as css
+            if let Some("scss" | "sass") = ext.as_deref() {
+                ext = Some("css".to_string());
+            }
+
+            let hash = hash.bytes();
+            let hash = hash
+                .iter()
+                .map(|byte| format!("{byte:x}"))
+                .collect::<String>();
+            let file_stem = source_path.file_stem().unwrap_or(file_name);
+            let mut bundled_path = PathBuf::from(format!("{}-{hash}", file_stem.to_string_lossy()));
+
+            if let Some(ext) = ext {
+                bundled_path.set_extension(ext);
+            }
+
+            let bundled_path = bundled_path.to_string_lossy().to_string();
+
+            *asset = BundledAsset::new(source, &bundled_path, options, asset.link_section());
+        }
+        Err(err) => {
+            tracing::error!("Failed to hash asset: {err}");
+        }
+    }
+}
diff --git a/packages/cli-opt/src/lib.rs b/packages/cli-opt/src/lib.rs
index a088311e6f..0cb0a68c2d 100644
--- a/packages/cli-opt/src/lib.rs
+++ b/packages/cli-opt/src/lib.rs
@@ -16,7 +16,7 @@ mod js;
 mod json;
 
 pub use file::process_file_to;
-pub use hash::AssetHash;
+pub use hash::add_hash_to_asset;
 
 /// A manifest of all assets collected from dependencies
 ///
@@ -38,7 +38,9 @@ impl AssetManifest {
             "Failed to convert wasm bindgen output path to string"
         ))?;
 
-        let bundled_asset = manganis::macro_helpers::create_bundled_asset(output_path_str, options);
+        let mut bundled_asset =
+            manganis::macro_helpers::create_bundled_asset(output_path_str, options, "");
+        add_hash_to_asset(&mut bundled_asset);
 
         self.assets
             .entry(asset_path.to_path_buf())
diff --git a/packages/cli/Cargo.toml b/packages/cli/Cargo.toml
index a007c9ea1b..8d1762e2bf 100644
--- a/packages/cli/Cargo.toml
+++ b/packages/cli/Cargo.toml
@@ -117,6 +117,7 @@ tempfile = "3.3"
 manganis = { workspace = true }
 manganis-core = { workspace = true }
 target-lexicon = "0.13.2"
+wasm-encoder = "0.229.0"
 
 # Extracting data from an executable
 object = { version = "0.36.0", features = ["wasm"] }
diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index de2f9101ab..cee81d088c 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -11,6 +11,7 @@ use std::io::{Read, Seek, Write};
 use std::path::PathBuf;
 use std::process::Command;
 use target_lexicon::Triple;
+use tempfile::NamedTempFile;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum LinkAction {
@@ -79,9 +80,10 @@ impl LinkAction {
             // Assemble an asset manifest by walking the object files being passed to us
             LinkAction::BuildAssetManifest { destination: dest } => {
                 let args: Vec<_> = std::env::args().collect();
-                let mut obj_args = args.clone();
                 let mut references = AssetReferences::default();
 
+                let mut obj_args = args.clone();
+                references.assets.clear();
                 // Handle command files, usually a windows thing.
                 if let Some(command) = args.iter().find(|arg| arg.starts_with('@')).cloned() {
                     let path = command.trim().trim_start_matches('@');
@@ -121,65 +123,47 @@ impl LinkAction {
 
                 // Hash each file in parallel
                 references.assets.par_iter_mut().for_each(|asset| {
-                    match dioxus_cli_opt::AssetHash::hash_file_contents(
-                        asset.bundled_asset.options(),
-                        &asset.file,
-                    ) {
-                        Ok(hash) => {
-                            let source = asset.bundled_asset.absolute_source_path();
-                            let options = asset.bundled_asset.options().clone();
-
-                            // Set the bundled path to the source path with the hash appended before the extension
-                            let source_path = PathBuf::from(source);
-                            let Some(file_name) = source_path.file_name() else {
-                                tracing::error!("Failed to get file name from path: {source}");
-                                return;
-                            };
-                            // The output extension path is the extension set by the options
-                            // or the extension of the source file if we don't recognize the file
-                            let mut ext = asset
-                                .bundled_asset
-                                .options()
-                                .extension()
-                                .map(Into::into)
-                                .or_else(|| {
-                                    source_path
-                                        .extension()
-                                        .map(|ext| ext.to_string_lossy().to_string())
-                                });
-
-                            // Rewrite scss as css
-                            if let Some("scss" | "sass") = ext.as_deref() {
-                                ext = Some("css".to_string());
-                            }
-
-                            let hash = hash.bytes();
-                            let hash = hash
-                                .iter()
-                                .map(|byte| format!("{byte:x}"))
-                                .collect::<String>();
-                            let file_stem = source_path.file_stem().unwrap_or(file_name);
-                            let mut bundled_path =
-                                PathBuf::from(format!("{}-{hash}", file_stem.to_string_lossy()));
-
-                            if let Some(ext) = ext {
-                                bundled_path.set_extension(ext);
-                            }
-
-                            let bundled_path = bundled_path.to_string_lossy().to_string();
-
-                            asset.bundled_asset = BundledAsset::new(source, &bundled_path, options);
-
-                            // Write the contents back to the object file
-                            if let Err(err) = asset.write() {
-                                tracing::error!("Failed to write asset back to object file: {err}");
-                            }
-                        }
-                        Err(err) => {
-                            tracing::error!("Failed to hash asset: {err}");
+                    dioxus_cli_opt::add_hash_to_asset(&mut asset.bundled_asset);
+                });
+
+                let targeting_wasm = args.contains(&"wasm".to_string());
+                let mut linker_args = args.into_iter().skip(1).collect::<Vec<_>>();
+                let mut _tempfile_handle = None;
+
+                // If we are targeting wasm, create an object file to satisfy the imports
+                if targeting_wasm {
+                    let mut data_sections = Vec::new();
+                    for asset in references.assets.iter() {
+                        let name = asset.bundled_asset.link_section();
+                        let data =
+                            const_serialize::serialize_const(&asset.bundled_asset, ConstVec::new());
+                        const_serialize::deserialize_const!(BundledAsset, data.read()).unwrap();
+                        data_sections.push((name, data.as_ref().to_vec()));
+                    }
+
+                    // Create the object file
+                    let object_file = create_data_object_file(
+                        data_sections
+                            .iter()
+                            .map(|(name, data)| (*name, data.as_ref())),
+                    );
+                    let mut temp_file =
+                        NamedTempFile::new().expect("Failed to create temporary file");
+                    temp_file
+                        .write_all(&object_file)
+                        .expect("Failed to write object file");
+                    linker_args.push(temp_file.path().to_string_lossy().to_string());
+                    _tempfile_handle = Some(temp_file);
+                }
+                // Otherwise overwrite the object files
+                else {
+                    for asset in &references.assets {
+                        // Write the asset to the object file
+                        if let Err(err) = asset.write() {
+                            tracing::error!("Failed to write asset to object file: {err}");
                         }
                     }
-                });
+                }
 
                 // Extract the manifest from the hashed assets
                 let mut manifest = AssetManifest::default();
@@ -197,7 +181,7 @@ impl LinkAction {
                     .create(true)
                     .open("/Users/evanalmloff/Desktop/Github/dioxus-test/linker_err.txt")
                     .unwrap();
-                let toolchain = if args.contains(&"wasm".to_string()) {
+                let toolchain = if targeting_wasm {
                     "stable-wasm32-unknown-unknown".to_string()
                 } else {
                     std::env::var("RUSTUP_TOOLCHAIN").unwrap()
@@ -205,7 +189,7 @@ impl LinkAction {
 
                 let mut linker_command = find_linker(toolchain);
                 let status = linker_command
-                    .args(args.into_iter().skip(1))
+                    .args(linker_args)
                     .stderr(err_file)
                     .status()
                     .expect("Failed to spawn linker");
@@ -258,7 +242,7 @@ impl AssetReferences {
                 if let Ok(name) = section.name() {
                     if manganis_core::linker::LinkSection::ALL
                         .iter()
-                        .any(|section| section.name == name)
+                        .any(|link_section| link_section.link_section == name)
                     {
                         if file.format() == object::BinaryFormat::Wasm {
                             // In wasm this is actually the start and end
@@ -338,3 +322,46 @@ fn wasm_ld() -> PathBuf {
         .join("rust-lld");
     root
 }
+
+fn create_data_object_file<'a>(
+    data_sections: impl IntoIterator<Item = (&'a str, &'a [u8])>,
+) -> Vec<u8> {
+    use wasm_encoder::{
+        ConstExpr, DataSection, DataSymbolDefinition, LinkingSection, Module, SymbolTable,
+    };
+
+    let mut linking = LinkingSection::new();
+
+    let mut sym_tab = SymbolTable::new();
+
+    let mut data_section = DataSection::new();
+    let memory_index = 0;
+
+    let mut offset = 0;
+    for (symbol_name, data) in data_sections {
+        let flags = SymbolTable::WASM_SYM_EXPORTED;
+        let index = 0;
+        let size = data.len() as u32;
+        data_section.active(
+            memory_index,
+            &ConstExpr::i32_const(offset as i32),
+            data.iter().copied(),
+        );
+        sym_tab.data(
+            flags,
+            symbol_name,
+            Some(DataSymbolDefinition {
+                index,
+                offset,
+                size,
+            }),
+        );
+        linking.symbol_table(&sym_tab);
+        offset += size;
+    }
+
+    // Add the linking section to a new Wasm module and get the encoded bytes.
+    let mut module = Module::new();
+    module.section(&data_section).section(&linking);
+    module.finish()
+}
diff --git a/packages/manganis/manganis-core/src/asset.rs b/packages/manganis/manganis-core/src/asset.rs
index d7db23be70..d783d1378d 100644
--- a/packages/manganis/manganis-core/src/asset.rs
+++ b/packages/manganis/manganis-core/src/asset.rs
@@ -1,6 +1,6 @@
 use crate::AssetOptions;
 use const_serialize::{deserialize_const, ConstStr, ConstVec, SerializeConst};
-use std::path::PathBuf;
+use std::{fmt::Debug, path::PathBuf};
 
 /// An asset that should be copied by the bundler with some options. This type will be
 /// serialized into the binary and added to the link section [`LinkSection::CURRENT`](crate::linker::LinkSection::CURRENT).
@@ -26,6 +26,8 @@ pub struct BundledAsset {
     bundled_path: ConstStr,
     /// The options for the asset
     options: AssetOptions,
+    /// The link section the wasm asset is bundled at
+    link_section: ConstStr,
 }
 
 impl BundledAsset {
@@ -36,11 +38,13 @@ impl BundledAsset {
         absolute_source_path: &str,
         bundled_path: &str,
         options: AssetOptions,
+        link_section: &str,
     ) -> Self {
         Self {
             absolute_source_path: ConstStr::new(absolute_source_path),
             bundled_path: ConstStr::new(bundled_path),
             options,
+            link_section: ConstStr::new(link_section),
         }
     }
 
@@ -56,8 +60,9 @@ impl BundledAsset {
         absolute_source_path: &'static str,
         bundled_path: &'static str,
         options: AssetOptions,
+        link_section: &'static str,
     ) -> Self {
-        Self::new(absolute_source_path, bundled_path, options)
+        Self::new(absolute_source_path, bundled_path, options, link_section)
     }
 
     #[doc(hidden)]
@@ -67,11 +72,13 @@ impl BundledAsset {
         absolute_source_path: ConstStr,
         bundled_path: ConstStr,
         options: AssetOptions,
+        link_section: ConstStr,
     ) -> Self {
         Self {
             absolute_source_path,
             bundled_path,
             options,
+            link_section,
         }
     }
 
@@ -84,10 +91,16 @@ impl BundledAsset {
     pub fn absolute_source_path(&self) -> &str {
         self.absolute_source_path.as_str()
     }
+
     /// Get the options for the asset
     pub const fn options(&self) -> &AssetOptions {
         &self.options
     }
+
+    /// Get the link section the asset is bundled at
+    pub fn link_section(&self) -> &str {
+        self.link_section.as_str()
+    }
 }
 
 /// A bundled asset with some options. The asset can be used in rsx! to reference the asset.
@@ -102,13 +115,19 @@ impl BundledAsset {
 ///     img { src: ASSET }
 /// };
 /// ```
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(PartialEq, Clone, Copy)]
 pub struct Asset {
     /// A pointer to the bundled asset. This will be resolved after the linker has run and
     /// put into the lazy asset
     bundled: *const [u8],
 }
 
+impl Debug for Asset {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.resolve().fmt(f)
+    }
+}
+
 unsafe impl Send for Asset {}
 unsafe impl Sync for Asset {}
 
diff --git a/packages/manganis/manganis-macro/src/asset.rs b/packages/manganis/manganis-macro/src/asset.rs
index 79bf3f968f..c0730a6eea 100644
--- a/packages/manganis/manganis-macro/src/asset.rs
+++ b/packages/manganis/manganis-macro/src/asset.rs
@@ -1,7 +1,11 @@
 use macro_string::MacroString;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::{quote, ToTokens, TokenStreamExt};
-use std::{iter, path::PathBuf};
+use std::{
+    hash::{DefaultHasher, Hash, Hasher},
+    iter,
+    path::PathBuf,
+};
 use syn::{
     parse::{Parse, ParseStream},
     spanned::Spanned as _,
@@ -136,13 +140,18 @@ impl ToTokens for AssetParser {
                 return;
             }
         };
-        let asset_str = asset.to_string_lossy();
-        let mut asset_str = proc_macro2::Literal::string(&asset_str);
+        let asset_string = asset.to_string_lossy();
+        let mut asset_str = proc_macro2::Literal::string(&asset_string);
         asset_str.set_span(self.path_expr.span());
 
+        let mut hash = DefaultHasher::new();
+        format!("{:?}", self.options.span()).hash(&mut hash);
+        asset_string.hash(&mut hash);
+        let asset_hash = format!("__MANGANIS_ASSET_{:x}", hash.finish());
+
         // Generate the link section for the asset
         // The link section includes the source path and the output path of the asset
-        let link_section = crate::generate_link_section(quote!(__ASSET));
+        let link_section = crate::generate_link_section(quote!(__ASSET), &asset_hash);
 
         // generate the asset::new method to deprecate the `./assets/blah.css` syntax
         let constructor = if asset.is_relative() {
@@ -165,12 +174,17 @@ impl ToTokens for AssetParser {
                 // Note: into_asset_options is not a trait, so we cannot accept the options directly
                 // in the constructor. Stable rust doesn't have support for constant functions in traits
                 const __ASSET_OPTIONS: manganis::AssetOptions = #options.into_asset_options();
+                // The input token hash is used to uniquely identify the link section for this asset
+                const __ASSET_HASH: &'static str = #asset_hash;
                 // Create the asset that the crate will use. This is used both in the return value and
                 // added to the linker for the bundler to copy later
-                const __ASSET: manganis::BundledAsset = manganis::macro_helpers::#constructor(__ASSET_SOURCE_PATH, __ASSET_OPTIONS);
+                const __ASSET: manganis::BundledAsset = manganis::macro_helpers::#constructor(__ASSET_SOURCE_PATH, __ASSET_OPTIONS, __ASSET_HASH);
 
                 #link_section
 
+                #[cfg(target_arch = "wasm32")]
+                static __REFERENCE_TO_LINK_SECTION: &'static [u8] = unsafe { &__WASM_LINK_SECTION };
+                #[cfg(not(target_arch = "wasm32"))]
                 static __REFERENCE_TO_LINK_SECTION: &'static [u8] = &__LINK_SECTION;
 
                 manganis::Asset::new(
diff --git a/packages/manganis/manganis-macro/src/linker.rs b/packages/manganis/manganis-macro/src/linker.rs
index 25471e4c3f..27cbcf0e8b 100644
--- a/packages/manganis/manganis-macro/src/linker.rs
+++ b/packages/manganis/manganis-macro/src/linker.rs
@@ -6,7 +6,7 @@ use quote::ToTokens;
 /// We force rust to store a serialized representation of the asset description
 /// inside a particular region of the binary, with the label "manganis".
 /// After linking, the "manganis" sections of the different object files will be merged.
-pub fn generate_link_section(asset: impl ToTokens) -> TokenStream2 {
+pub fn generate_link_section(asset: impl ToTokens, asset_hash: &str) -> TokenStream2 {
     let position = proc_macro2::Span::call_site();
     let section_name = syn::LitStr::new(
         manganis_core::linker::LinkSection::CURRENT.link_section,
@@ -23,6 +23,13 @@ pub fn generate_link_section(asset: impl ToTokens) -> TokenStream2 {
 
         // Now that we have the size of the asset, copy the bytes into a static array
         #[link_section = #section_name]
+        #[cfg_attr(target_arch = "wasm32", used)]
         static __LINK_SECTION: [u8; __LEN] = manganis::macro_helpers::copy_bytes(__BYTES);
+
+        #[cfg(target_arch = "wasm32")]
+        extern "C" {
+            #[link_name = #asset_hash]
+            static __WASM_LINK_SECTION: [u8; __LEN];
+        }
     }
 }
diff --git a/packages/manganis/manganis/src/macro_helpers.rs b/packages/manganis/manganis/src/macro_helpers.rs
index c6a19bcdad..0745fa9eb3 100644
--- a/packages/manganis/manganis/src/macro_helpers.rs
+++ b/packages/manganis/manganis/src/macro_helpers.rs
@@ -6,8 +6,17 @@ const PLACEHOLDER_HASH: ConstStr =
     ConstStr::new("this is a placeholder path which will be replaced by the linker");
 
 /// Create a bundled asset from the input path, the content hash, and the asset options
-pub const fn create_bundled_asset(input_path: &str, asset_config: AssetOptions) -> BundledAsset {
-    BundledAsset::new_from_const(ConstStr::new(input_path), PLACEHOLDER_HASH, asset_config)
+pub const fn create_bundled_asset(
+    input_path: &str,
+    asset_config: AssetOptions,
+    link_section: &str,
+) -> BundledAsset {
+    BundledAsset::new_from_const(
+        ConstStr::new(input_path),
+        PLACEHOLDER_HASH,
+        asset_config,
+        ConstStr::new(link_section),
+    )
 }
 
 /// Create a bundled asset from the input path, the content hash, and the asset options with a relative asset deprecation warning
@@ -19,8 +28,9 @@ pub const fn create_bundled_asset(input_path: &str, asset_config: AssetOptions)
 pub const fn create_bundled_asset_relative(
     input_path: &str,
     asset_config: AssetOptions,
+    link_section: &str,
 ) -> BundledAsset {
-    create_bundled_asset(input_path, asset_config)
+    create_bundled_asset(input_path, asset_config, link_section)
 }
 
 /// Serialize an asset to a const buffer

From 9844b9037027524feff22b536a61e32bbd1a5bf8 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Wed, 30 Apr 2025 09:40:40 -0500
Subject: [PATCH 09/11] Fix multiple assets

---
 Cargo.lock                                    | 800 +++++++++---------
 packages/cli-opt/src/hash.rs                  |   3 +-
 packages/cli/src/build/bundle.rs              |   5 +-
 packages/cli/src/cli/link.rs                  |  40 +-
 packages/const-serialize/src/const_vec.rs     |  14 +
 packages/const-serialize/tests/enum.rs        |  61 ++
 packages/manganis/manganis-core/src/asset.rs  |  50 +-
 packages/manganis/manganis-macro/src/asset.rs |   3 +-
 8 files changed, 558 insertions(+), 418 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bfcea341c0..639ad88cde 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -175,7 +175,7 @@ version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "once_cell",
  "version_check",
 ]
@@ -188,7 +188,7 @@ checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if",
  "const-random",
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "once_cell",
  "serde",
  "version_check",
@@ -369,9 +369,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "anymap2"
@@ -453,7 +453,7 @@ dependencies = [
  "scroll",
  "security-framework 2.11.1",
  "security-framework-sys",
- "semver 1.0.26",
+ "semver",
  "serde",
  "serde_json",
  "serde_yaml",
@@ -554,7 +554,7 @@ checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -685,7 +685,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "swc_macros_common",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -725,11 +725,11 @@ dependencies = [
 
 [[package]]
 name = "async-compression"
-version = "0.4.22"
+version = "0.4.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59a194f9d963d8099596278594b3107448656ba73831c9d8c783e613ce86da64"
+checksum = "b37fc50485c4f3f736a4fb14199f6d5f5ba008d7f28fe710306c92780f004c07"
 dependencies = [
- "brotli 7.0.0",
+ "brotli 8.0.0",
  "flate2",
  "futures-core",
  "futures-io",
@@ -742,14 +742,15 @@ dependencies = [
 
 [[package]]
 name = "async-executor"
-version = "1.13.1"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30ca9a001c1e8ba5149f91a74362376cc6bc5b919d92d988668657bd570bdcec"
+checksum = "bb812ffb58524bdd10860d7d974e2f01cc0950c2438a74ee5ec2e2280c6c4ffa"
 dependencies = [
  "async-task",
  "concurrent-queue",
  "fastrand",
  "futures-lite",
+ "pin-project-lite",
  "slab",
 ]
 
@@ -842,7 +843,7 @@ checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -908,7 +909,7 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -925,7 +926,7 @@ checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1048,13 +1049,13 @@ dependencies = [
 
 [[package]]
 name = "auto_impl"
-version = "1.2.1"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e12882f59de5360c748c4cbf569a042d5fb0eb515f7bea9c1f470b47f6ffbd73"
+checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1099,9 +1100,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.28.0"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f7720b74ed28ca77f90769a71fd8c637a0137f6fae4ae947e1050229cff57f"
+checksum = "bfa9b6986f250236c27e5a204062434a773a13243d2ffc2955f37bdba4c5c6a1"
 dependencies = [
  "bindgen",
  "cc",
@@ -1252,7 +1253,7 @@ dependencies = [
  "hyper 1.6.0",
  "hyper-util",
  "pin-project-lite",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-pemfile 2.2.0",
  "rustls-pki-types",
  "tokio",
@@ -1364,6 +1365,16 @@ dependencies = [
  "simd-abstraction",
 ]
 
+[[package]]
+name = "base64-simd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
+dependencies = [
+ "outref 0.5.2",
+ "vsimd",
+]
+
 [[package]]
 name = "base64ct"
 version = "1.7.3"
@@ -1419,7 +1430,7 @@ dependencies = [
  "regex",
  "rustc-hash 1.1.0",
  "shlex",
- "syn 2.0.100",
+ "syn 2.0.101",
  "which 4.4.2",
 ]
 
@@ -1666,11 +1677,11 @@ dependencies = [
 
 [[package]]
 name = "block2"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d59b4c170e16f0405a2e95aff44432a0d41aa97675f3d52623effe95792a037"
+checksum = "340d2f0bdb2a43c1d3cd40513185b2bd7def0aa1052f956455114bc98f82dcf2"
 dependencies = [
- "objc2 0.6.0",
+ "objc2 0.6.1",
 ]
 
 [[package]]
@@ -1716,7 +1727,7 @@ dependencies = [
  "proc-macro-crate 3.3.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1727,25 +1738,35 @@ checksum = "74f7971dbd9326d58187408ab83117d8ac1bb9c17b085fdacd1cf2f598719b6b"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
- "brotli-decompressor",
+ "brotli-decompressor 4.0.3",
 ]
 
 [[package]]
 name = "brotli"
-version = "7.0.0"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf19e729cdbd51af9a397fb9ef8ac8378007b797f8273cfbfdf45dcaa316167b"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor 5.0.0",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "4.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc97b8f16f944bba54f0433f07e30be199b6dc2bd25937444bbad560bcea29bd"
+checksum = "a334ef7c9e23abf0ce748e8cd309037da93e606ad52eb372e4ce327a0dcfbdfd"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
- "brotli-decompressor",
 ]
 
 [[package]]
 name = "brotli-decompressor"
-version = "4.0.2"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74fa05ad7d803d413eb8380983b092cbbaf9a85f151b871360e7b00cd7060b37"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -1848,9 +1869,9 @@ dependencies = [
 
 [[package]]
 name = "bytemuck"
-version = "1.22.0"
+version = "1.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6b1fc10dbac614ebc03540c9dbd60e83887fda27794998c6528f1782047d540"
+checksum = "9134a6ef01ce4b366b50689c94f82c14bc72bc5d0386829828a2e2752ef7958c"
 dependencies = [
  "bytemuck_derive",
 ]
@@ -1863,7 +1884,7 @@ checksum = "7ecc273b49b3205b83d648f0690daa588925572cc5063745bfe547fe7ec8e1a1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -1988,7 +2009,7 @@ checksum = "6dc3749a36e0423c991f1e7a3e4ab0c36a1f489658313db4b187d401d79cc461"
 dependencies = [
  "serde",
  "serde_derive",
- "toml_edit 0.22.24",
+ "toml_edit 0.22.26",
  "windows-sys 0.59.0",
 ]
 
@@ -2025,7 +2046,7 @@ dependencies = [
  "remove_dir_all",
  "rhai",
  "sanitize-filename",
- "semver 1.0.26",
+ "semver",
  "serde",
  "tempfile",
  "thiserror 1.0.69",
@@ -2051,7 +2072,7 @@ checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037"
 dependencies = [
  "camino",
  "cargo-platform",
- "semver 1.0.26",
+ "semver",
  "serde",
  "serde_json",
  "thiserror 1.0.69",
@@ -2108,9 +2129,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.18"
+version = "1.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525046617d8376e3db1deffb079e91cef90a89fc3ca5c185bbf8c9ecdd15cd5c"
+checksum = "04da6a0d40b948dfc4fa8f5bbf402b0fc1a64a28dbf7d12ffd683550f2c1b63a"
 dependencies = [
  "jobserver",
  "libc",
@@ -2191,9 +2212,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
-version = "0.4.40"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a7964611d71df112cb1730f2ee67324fcf4d0fc6606acbbe9bfe06df124637c"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -2254,9 +2275,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.35"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
+checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -2264,9 +2285,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.35"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
+checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
 dependencies = [
  "anstream",
  "anstyle",
@@ -2284,7 +2305,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -2564,7 +2585,7 @@ version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "once_cell",
  "tiny-keccak",
 ]
@@ -2585,7 +2606,7 @@ version = "0.6.3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3054,7 +3075,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331"
 dependencies = [
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3064,7 +3085,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
 dependencies = [
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3104,7 +3125,7 @@ dependencies = [
  "digest",
  "fiat-crypto 0.2.9",
  "rand_core 0.6.4",
- "rustc_version 0.4.1",
+ "rustc_version",
  "subtle",
  "zeroize",
 ]
@@ -3117,7 +3138,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3131,9 +3152,9 @@ dependencies = [
 
 [[package]]
 name = "cxx"
-version = "1.0.156"
+version = "1.0.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa3a202fc4f3dd6d2ce5a2f87b04fb2becc00f5643ee9c4743ba10777efb314f"
+checksum = "a71ea7f29c73f7ffa64c50b83c9fe4d3a6d4be89a86b009eb80d5a6d3429d741"
 dependencies = [
  "cc",
  "cxxbridge-cmd",
@@ -3145,47 +3166,47 @@ dependencies = [
 
 [[package]]
 name = "cxx-build"
-version = "1.0.156"
+version = "1.0.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "644bdf46f34f6325783f76a8ad8e737ab995a302d7868b5236a1ba55008883e0"
+checksum = "36a8232661d66dcf713394726157d3cfe0a89bfc85f52d6e9f9bbc2306797fe7"
 dependencies = [
  "cc",
  "codespan-reporting 0.12.0",
  "proc-macro2",
  "quote",
  "scratch",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "cxxbridge-cmd"
-version = "1.0.156"
+version = "1.0.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e8cefbebcb74ed0b4a08b76139e6c29d8884a0bb94d02c6f35de821a14a6e39"
+checksum = "4f44296c8693e9ea226a48f6a122727f77aa9e9e338380cb021accaeeb7ee279"
 dependencies = [
  "clap",
  "codespan-reporting 0.12.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.156"
+version = "1.0.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "604e3eff62e2f27289d618f621491a068330c3c9f8eb06555dabc292c123596e"
+checksum = "c42f69c181c176981ae44ba9876e2ea41ce8e574c296b38d06925ce9214fb8e4"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.156"
+version = "1.0.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "130c3a05501d9c15dedbf08f2ff9af60f8e78422e3dffac1f43e2d83c5b489a1"
+checksum = "8faff5d4467e0709448187df29ccbf3b0982cc426ee444a193f87b11afb565a8"
 dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3220,7 +3241,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3231,7 +3252,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3263,9 +3284,9 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.8.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "575f75dfd25738df5b91b8e43e14d44bda14637a58fae779fd2b064f8bf3e010"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
 
 [[package]]
 name = "data-url"
@@ -3303,9 +3324,9 @@ dependencies = [
 
 [[package]]
 name = "der"
-version = "0.7.9"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
 dependencies = [
  "const-oid",
  "pem-rfc7468",
@@ -3330,7 +3351,7 @@ checksum = "30542c1ad912e0e3d22a1935c290e12e8a29d704a420177a31faad4a601a0800"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3351,7 +3372,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3361,20 +3382,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
 dependencies = [
  "derive_builder_core",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "derive_more"
-version = "0.99.19"
+version = "0.99.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3da29a38df43d6f156149c9b43ded5e018ddff2a855cf2cfd62e8cd7d079c69f"
+checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
 dependencies = [
  "convert_case 0.4.0",
  "proc-macro2",
  "quote",
- "rustc_version 0.4.1",
- "syn 2.0.100",
+ "rustc_version",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3394,7 +3415,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "unicode-xid",
 ]
 
@@ -3507,7 +3528,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3519,7 +3540,7 @@ dependencies = [
  "pretty_assertions",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -3594,11 +3615,11 @@ dependencies = [
  "rayon",
  "regex",
  "reqwest 0.12.15",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "serde",
  "serde_json",
  "strum 0.26.3",
- "syn 2.0.100",
+ "syn 2.0.101",
  "tar",
  "target-lexicon 0.13.2",
  "tauri-bundler",
@@ -3610,7 +3631,7 @@ dependencies = [
  "tokio-stream",
  "tokio-util",
  "toml",
- "toml_edit 0.22.24",
+ "toml_edit 0.22.26",
  "tower 0.4.13",
  "tower-http",
  "tracing",
@@ -3621,7 +3642,7 @@ dependencies = [
  "wasm-encoder 0.229.0",
  "wasm-opt",
  "wasm-split-cli",
- "which 7.0.2",
+ "which 7.0.3",
 ]
 
 [[package]]
@@ -3743,7 +3764,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.100",
+ "syn 2.0.101",
  "tokio",
  "trybuild",
 ]
@@ -3874,7 +3895,7 @@ dependencies = [
  "dioxus-ssr",
  "form_urlencoded",
  "futures-util",
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "http-range",
  "openssl",
  "ouroboros",
@@ -3896,7 +3917,7 @@ dependencies = [
  "dioxus-autofmt",
  "dioxus-rsx-rosetta",
  "html_parser",
- "syn 2.0.100",
+ "syn 2.0.101",
  "wasm-bindgen",
 ]
 
@@ -3934,7 +3955,7 @@ dependencies = [
  "once_cell",
  "parking_lot",
  "pin-project",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "serde",
  "server_fn",
  "thiserror 1.0.69",
@@ -4037,7 +4058,7 @@ dependencies = [
  "convert_case 0.6.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "trybuild",
 ]
 
@@ -4261,7 +4282,7 @@ dependencies = [
  "quote",
  "sha2",
  "slab",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4273,7 +4294,7 @@ dependencies = [
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4287,7 +4308,7 @@ dependencies = [
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "tracing",
 ]
 
@@ -4304,7 +4325,7 @@ dependencies = [
  "pretty_assertions",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4394,7 +4415,7 @@ dependencies = [
  "quote",
  "serde",
  "server_fn_macro",
- "syn 2.0.100",
+ "syn 2.0.101",
  "tower-http",
 ]
 
@@ -4457,6 +4478,16 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
 
+[[package]]
+name = "dispatch2"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec"
+dependencies = [
+ "bitflags 2.9.0",
+ "objc2 0.6.1",
+]
+
 [[package]]
 name = "displaydoc"
 version = "0.2.5"
@@ -4465,7 +4496,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4503,7 +4534,7 @@ checksum = "f2b99bf03862d7f545ebc28ddd33a665b50865f4dfd84031a393823879bd4c54"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4718,7 +4749,7 @@ checksum = "ba7795da175654fe16979af73f81f26a8ea27638d8d9823d317016888a63dc4c"
 dependencies = [
  "num-traits",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4739,7 +4770,7 @@ checksum = "fc4caf64a58d7a6d65ab00639b046ff54399a39f5f2554728895ace4b297cd79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4760,7 +4791,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -4833,9 +4864,9 @@ dependencies = [
 
 [[package]]
 name = "escargot"
-version = "0.5.13"
+version = "0.5.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05a3ac187a16b5382fef8c69fd1bad123c67b7cf3932240a2d43dcdd32cded88"
+checksum = "83f351750780493fc33fa0ce8ba3c7d61f9736cfa3b3bb9ee2342643ffe40211"
 dependencies = [
  "log",
  "once_cell",
@@ -4919,7 +4950,7 @@ checksum = "ce8cd46a041ad005ab9c71263f9a0ff5b529eac0fe4cc9b4a20f4f0765d8cf4b"
 dependencies = [
  "execute-command-tokens",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5005,7 +5036,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
 dependencies = [
  "memoffset",
- "rustc_version 0.4.1",
+ "rustc_version",
 ]
 
 [[package]]
@@ -5142,7 +5173,7 @@ dependencies = [
  "memmap2",
  "objc2-core-foundation",
  "objc2-core-text",
- "objc2-foundation 0.3.0",
+ "objc2-foundation 0.3.1",
  "peniko",
  "read-fonts",
  "roxmltree",
@@ -5178,7 +5209,7 @@ checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5220,7 +5251,7 @@ checksum = "8d7ccf961415e7aa17ef93dcb6c2441faaa8e768abe09e659b908089546f74c5"
 dependencies = [
  "proc-macro2",
  "swc_macros_common",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5438,7 +5469,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -5632,9 +5663,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -5872,7 +5903,7 @@ dependencies = [
  "gix-features",
  "gix-hash",
  "gix-utils",
- "gix-validate",
+ "gix-validate 0.8.5",
  "itoa 1.0.15",
  "smallvec",
  "thiserror 1.0.69",
@@ -5881,12 +5912,13 @@ dependencies = [
 
 [[package]]
 name = "gix-path"
-version = "0.10.15"
+version = "0.10.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f910668e2f6b2a55ff35a1f04df88a1a049f7b868507f4cbeeaa220eaba7be87"
+checksum = "c091d2e887e02c3462f52252c5ea61150270c0f2657b642e8d0d6df56c16e642"
 dependencies = [
  "bstr",
  "gix-trace",
+ "gix-validate 0.10.0",
  "home",
  "once_cell",
  "thiserror 2.0.12",
@@ -5908,7 +5940,7 @@ dependencies = [
  "gix-path",
  "gix-tempfile",
  "gix-utils",
- "gix-validate",
+ "gix-validate 0.8.5",
  "memmap2",
  "thiserror 1.0.69",
  "winnow 0.6.26",
@@ -5965,6 +5997,16 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "gix-validate"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77b9e00cacde5b51388d28ed746c493b18a6add1f19b5e01d686b3b9ece66d4d"
+dependencies = [
+ "bstr",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "gl_generator"
 version = "0.14.0"
@@ -6010,7 +6052,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -6280,7 +6322,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7a68216437ef68f0738e48d6c7bb9e6e6a92237e001b03d838314b068f33c94"
 dependencies = [
  "clap",
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "grass_compiler",
 ]
 
@@ -6300,9 +6342,9 @@ dependencies = [
 
 [[package]]
 name = "grid"
-version = "0.16.1"
+version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb6ae361963ea5fe52038156ea1729f3b4e4ccc0711c362ab2b2d2c0a259e7c3"
+checksum = "969d090eea77fac1be33f853ffc4b6b60cc6f312ddf4fd28b311a730e1dd8ebe"
 
 [[package]]
 name = "group"
@@ -6364,7 +6406,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -6398,9 +6440,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5017294ff4bb30944501348f6f8e42e6ad28f42c8bbef7a74029aff064a4e3c2"
+checksum = "75249d144030531f8dee69fe9cea04d3edf809a017ae445e2abdff6629e86633"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -6797,7 +6839,7 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "h2 0.4.8",
+ "h2 0.4.9",
  "http 1.3.1",
  "http-body 1.0.1",
  "httparse",
@@ -6834,13 +6876,13 @@ dependencies = [
  "hyper 1.6.0",
  "hyper-util",
  "log",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-native-certs 0.8.1",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.2",
  "tower-service",
- "webpki-roots 0.26.8",
+ "webpki-roots 0.26.9",
 ]
 
 [[package]]
@@ -7030,7 +7072,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7304,7 +7346,7 @@ dependencies = [
  "indoc",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7334,7 +7376,7 @@ checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7389,7 +7431,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7522,9 +7564,9 @@ dependencies = [
 
 [[package]]
 name = "jiff"
-version = "0.2.6"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f33145a5cbea837164362c7bd596106eb7c5198f97d1ba6f6ebb3223952e488"
+checksum = "5a064218214dc6a10fbae5ec5fa888d80c45d611aba169222fc272072bf7aef6"
 dependencies = [
  "jiff-static",
  "log",
@@ -7535,13 +7577,13 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.6"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43ce13c40ec6956157a3635d97a1ee2df323b263f09ea14165131289cb0f5c19"
+checksum = "199b7932d97e325aff3a7030e141eafe7f2c6268e1d1b24859b753a627f45254"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -7730,7 +7772,7 @@ dependencies = [
  "camino",
  "cfg-expr 0.17.2",
  "petgraph",
- "semver 1.0.26",
+ "semver",
  "serde",
  "serde_json",
 ]
@@ -7760,9 +7802,9 @@ dependencies = [
 
 [[package]]
 name = "kurbo"
-version = "0.11.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89234b2cc610a7dd927ebde6b41dd1a5d4214cffaef4cf1fb2195d592f92518f"
+checksum = "1077d333efea6170d9ccb96d3c3026f300ca0773da4938cc4c811daa6df68b0c"
 dependencies = [
  "arrayvec",
  "smallvec",
@@ -7849,9 +7891,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -7899,9 +7941,9 @@ dependencies = [
 
 [[package]]
 name = "libm"
-version = "0.2.11"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
+checksum = "c9627da5196e5d8ed0b0495e61e518847578da83483c37288316d9b2e03a7f72"
 
 [[package]]
 name = "libredox"
@@ -7984,7 +8026,7 @@ dependencies = [
  "cssparser-color",
  "dashmap 5.5.3",
  "data-encoding",
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "indexmap 2.9.0",
  "itertools 0.10.5",
  "lazy_static",
@@ -8028,9 +8070,9 @@ checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
 [[package]]
 name = "liquid"
@@ -8069,7 +8111,7 @@ checksum = "de66c928222984aea59fcaed8ba627f388aaac3c1f57dcb05cc25495ef8faefe"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -8100,13 +8142,13 @@ checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
 
 [[package]]
 name = "local-ip-address"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3669cf5561f8d27e8fc84cc15e58350e70f557d4d65f70e3154e54cd2f8e1782"
+checksum = "c986b1747bbd3666abe4d57c64e60e6a82c2216140d8b12d5ceb33feb9de44b3"
 dependencies = [
  "libc",
  "neli",
- "thiserror 1.0.69",
+ "thiserror 2.0.12",
  "windows-sys 0.59.0",
 ]
 
@@ -8120,12 +8162,6 @@ dependencies = [
  "scopeguard",
 ]
 
-[[package]]
-name = "lockfree-object-pool"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9374ef4228402d4b7e403e5838cb880d9ee663314b0a900d5a6aabf0c213552e"
-
 [[package]]
 name = "log"
 version = "0.4.27"
@@ -8212,7 +8248,7 @@ checksum = "1b27834086c65ec3f9387b096d66e99f221cf081c2b738042aa252bcd41204e3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -8231,7 +8267,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f44db74bde26fdf427af23f1d146c211aed857c59e3be750cf2617f6b0b05c94"
 dependencies = [
  "proc-macro2",
- "syn 2.0.100",
+ "syn 2.0.101",
  "synstructure 0.13.1",
 ]
 
@@ -8266,7 +8302,7 @@ dependencies = [
  "manganis-core",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -8906,7 +8942,7 @@ checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -8993,7 +9029,7 @@ dependencies = [
  "proc-macro-crate 3.3.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -9050,9 +9086,9 @@ dependencies = [
 
 [[package]]
 name = "objc2"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3531f65190d9cff863b77a99857e74c314dd16bf56c538c4b57c7cbc3f3a6e59"
+checksum = "88c6597e14493ab2e44ce58f2fdecf095a51f12ca57bec060a11c57332520551"
 dependencies = [
  "objc2-encode",
  "objc2-exception-helper",
@@ -9076,14 +9112,14 @@ dependencies = [
 
 [[package]]
 name = "objc2-app-kit"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5906f93257178e2f7ae069efb89fbd6ee94f0592740b5f8a1512ca498814d0fb"
+checksum = "e6f29f568bec459b0ddff777cec4fe3fd8666d82d5a40ebd0ff7e66134f89bcc"
 dependencies = [
  "bitflags 2.9.0",
- "objc2 0.6.0",
+ "objc2 0.6.1",
  "objc2-core-foundation",
- "objc2-foundation 0.3.0",
+ "objc2-foundation 0.3.1",
 ]
 
 [[package]]
@@ -9124,19 +9160,20 @@ dependencies = [
 
 [[package]]
 name = "objc2-core-foundation"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daeaf60f25471d26948a1c2f840e3f7d86f4109e3af4e8e4b5cd70c39690d925"
+checksum = "1c10c2894a6fed806ade6027bcd50662746363a9589d3ec9d9bef30a4e4bc166"
 dependencies = [
  "bitflags 2.9.0",
- "objc2 0.6.0",
+ "dispatch2",
+ "objc2 0.6.1",
 ]
 
 [[package]]
 name = "objc2-core-graphics"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dca602628b65356b6513290a21a6405b4d4027b8b250f0b98dddbb28b7de02"
+checksum = "989c6c68c13021b5c2d6b71456ebb0f9dc78d752e86a98da7c716f4f9470f5a4"
 dependencies = [
  "bitflags 2.9.0",
  "objc2-core-foundation",
@@ -9168,9 +9205,9 @@ dependencies = [
 
 [[package]]
 name = "objc2-core-text"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fde15abfe00bf9f1eda220addbdfa6c62b0e5595e98208e8cdbc2ec0f6970a6"
+checksum = "3ba833d4a1cb1aac330f8c973fd92b6ff1858e4aef5cdd00a255eefb28022fb5"
 dependencies = [
  "bitflags 2.9.0",
  "objc2-core-foundation",
@@ -9206,13 +9243,13 @@ dependencies = [
 
 [[package]]
 name = "objc2-foundation"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a21c6c9014b82c39515db5b396f91645182611c97d24637cf56ac01e5f8d998"
+checksum = "900831247d2fe1a09a683278e5384cfb8c80c79fe6b166f9d14bfdde0ea1b03c"
 dependencies = [
  "bitflags 2.9.0",
- "block2 0.6.0",
- "objc2 0.6.0",
+ "block2 0.6.1",
+ "objc2 0.6.1",
  "objc2-core-foundation",
 ]
 
@@ -9286,14 +9323,14 @@ dependencies = [
 
 [[package]]
 name = "objc2-ui-kit"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "777a571be14a42a3990d4ebedaeb8b54cd17377ec21b92e8200ac03797b3bee1"
+checksum = "25b1312ad7bc8a0e92adae17aa10f90aae1fb618832f9b993b022b591027daed"
 dependencies = [
  "bitflags 2.9.0",
- "objc2 0.6.0",
+ "objc2 0.6.1",
  "objc2-core-foundation",
- "objc2-foundation 0.3.0",
+ "objc2-foundation 0.3.1",
 ]
 
 [[package]]
@@ -9322,16 +9359,16 @@ dependencies = [
 
 [[package]]
 name = "objc2-web-kit"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b717127e4014b0f9f3e8bba3d3f2acec81f1bde01f656823036e823ed2c94dce"
+checksum = "91672909de8b1ce1c2252e95bbee8c1649c9ad9d14b9248b3d7b4c47903c47ad"
 dependencies = [
  "bitflags 2.9.0",
- "block2 0.6.0",
- "objc2 0.6.0",
- "objc2-app-kit 0.3.0",
+ "block2 0.6.1",
+ "objc2 0.6.1",
+ "objc2-app-kit 0.3.1",
  "objc2-core-foundation",
- "objc2-foundation 0.3.0",
+ "objc2-foundation 0.3.1",
 ]
 
 [[package]]
@@ -9461,7 +9498,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -9472,9 +9509,9 @@ checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
 [[package]]
 name = "openssl-src"
-version = "300.4.2+3.4.1"
+version = "300.5.0+3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168ce4e058f975fe43e89d9ccf78ca668601887ae736090aacc23ae353c298e2"
+checksum = "e8ce546f549326b0e6052b649198487d91320875da901e7bd11a06d1ee3f9c2f"
 dependencies = [
  "cc",
 ]
@@ -9548,7 +9585,7 @@ dependencies = [
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -9557,6 +9594,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f222829ae9293e33a9f5e9f440c6760a3d450a64affe1846486b140db81c1f4"
 
+[[package]]
+name = "outref"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
+
 [[package]]
 name = "overload"
 version = "0.1.1"
@@ -9591,7 +9634,7 @@ dependencies = [
  "cbc",
  "cipher",
  "des",
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "hmac",
  "lazy_static",
  "rc2",
@@ -9685,7 +9728,7 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "485b74d7218068b2b7c0e3ff12fbc61ae11d57cb5d8224f525bd304c6be05bbb"
 dependencies = [
- "base64-simd",
+ "base64-simd 0.7.0",
  "data-url 0.1.1",
  "rkyv",
  "serde",
@@ -9802,7 +9845,7 @@ dependencies = [
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -9872,7 +9915,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10077,7 +10120,7 @@ dependencies = [
  "phf_shared 0.11.3",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10130,7 +10173,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10309,7 +10352,7 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
 dependencies = [
- "zerocopy 0.8.24",
+ "zerocopy 0.8.25",
 ]
 
 [[package]]
@@ -10331,7 +10374,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32db37eb2b0ec0af154e9c1b33425902d8cd9481e35167c4e9ffb28fec3916bb"
 dependencies = [
  "proc-macro2",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10351,7 +10394,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6"
 dependencies = [
  "proc-macro2",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10388,7 +10431,7 @@ version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edce586971a4dfaa28950c6f18ed55e0406c1ab88bbce2c6f6293a7aaba73d35"
 dependencies = [
- "toml_edit 0.22.24",
+ "toml_edit 0.22.26",
 ]
 
 [[package]]
@@ -10423,9 +10466,9 @@ checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -10438,7 +10481,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "version_check",
  "yansi",
 ]
@@ -10465,7 +10508,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a65f2e60fbf1063868558d69c6beacf412dc755f9fc020f514b7955fc914fe30"
 dependencies = [
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10488,7 +10531,7 @@ dependencies = [
  "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10502,9 +10545,9 @@ dependencies = [
 
 [[package]]
 name = "psm"
-version = "0.1.25"
+version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f58e5423e24c18cc840e1c98370b3993c6649cd1678b4d24318bcf0a083cbe88"
+checksum = "6e944464ec8536cd1beb0bbfd96987eb5e3b72f2ecdafdc5c769a37f1fa2ae1f"
 dependencies = [
  "cc",
 ]
@@ -10546,7 +10589,7 @@ checksum = "ca414edb151b4c8d125c12566ab0d74dc9cdba36fb80eb7b848c15f495fd32d1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -10585,9 +10628,9 @@ dependencies = [
 
 [[package]]
 name = "quick-xml"
-version = "0.37.4"
+version = "0.37.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4ce8c88de324ff838700f36fb6ab86c96df0e3c4ab6ef3a9b2044465cce1369"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
 dependencies = [
  "memchr",
 ]
@@ -10604,7 +10647,7 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash 2.1.1",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "socket2",
  "thiserror 2.0.12",
  "tokio",
@@ -10614,16 +10657,16 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.10"
+version = "0.11.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b820744eb4dc9b57a3398183639c511b5a26d2ed702cedd3febaa1393caa22cc"
+checksum = "bcbafbbdbb0f638fe3f35f3c56739f77a8a1d070cb25603226c83339b391472b"
 dependencies = [
  "bytes",
  "getrandom 0.3.2",
- "rand 0.9.0",
+ "rand 0.9.1",
  "ring",
  "rustc-hash 2.1.1",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-pki-types",
  "slab",
  "thiserror 2.0.12",
@@ -10700,13 +10743,12 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
- "zerocopy 0.8.24",
 ]
 
 [[package]]
@@ -10754,7 +10796,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
 ]
 
 [[package]]
@@ -10886,9 +10928,9 @@ dependencies = [
 
 [[package]]
 name = "ravif"
-version = "0.11.11"
+version = "0.11.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2413fd96bd0ea5cdeeb37eaf446a22e6ed7b981d792828721e74ded1980a45c6"
+checksum = "d6a5f31fcf7500f9401fea858ea4ab5525c99f2322cfcee732c0e6c74208c0c6"
 dependencies = [
  "avif-serialize",
  "imgref",
@@ -10974,7 +11016,7 @@ version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "libredox",
  "thiserror 1.0.69",
 ]
@@ -10985,7 +11027,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "libredox",
  "thiserror 2.0.12",
 ]
@@ -11123,7 +11165,7 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2 0.4.8",
+ "h2 0.4.9",
  "http 1.3.1",
  "http-body 1.0.1",
  "http-body-util",
@@ -11141,7 +11183,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-pemfile 2.2.0",
  "rustls-pki-types",
  "serde",
@@ -11160,7 +11202,7 @@ dependencies = [
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots 0.26.8",
+ "webpki-roots 0.26.9",
  "windows-registry",
 ]
 
@@ -11231,7 +11273,7 @@ checksum = "a5a11a05ee1ce44058fa3d5961d05194fdbe3ad6b40f904af764d81b86450e6b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11242,7 +11284,7 @@ checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
  "cfg-if",
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "libc",
  "untrusted 0.9.0",
  "windows-sys 0.52.0",
@@ -11376,22 +11418,13 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
-[[package]]
-name = "rustc_version"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-dependencies = [
- "semver 0.9.0",
-]
-
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
- "semver 1.0.26",
+ "semver",
 ]
 
 [[package]]
@@ -11425,7 +11458,7 @@ dependencies = [
  "bitflags 2.9.0",
  "errno",
  "libc",
- "linux-raw-sys 0.9.3",
+ "linux-raw-sys 0.9.4",
  "windows-sys 0.59.0",
 ]
 
@@ -11457,9 +11490,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.25"
+version = "0.23.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "822ee9188ac4ec04a2f0531e55d035fb2de73f18b41a63c70c2712503b6fb13c"
+checksum = "df51b5869f3a441595eac5e8ff14d486ff285f7b8c0df8770e49c3b56351f0f0"
 dependencies = [
  "aws-lc-rs",
  "log",
@@ -11599,7 +11632,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "58c4eb8a81997cf040a091d1f7e1938aeab6749d3a0dfa73af43cdc32393483d"
 dependencies = [
  "byteorder",
- "derive_more 0.99.19",
+ "derive_more 0.99.20",
  "twox-hash",
 ]
 
@@ -11687,7 +11720,7 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11777,7 +11810,7 @@ checksum = "df320f1889ac4ba6bc0cdc9c9af7af4bd64bb927bccdf32d81140dc1f9be12fe"
 dependencies = [
  "bitflags 1.3.2",
  "cssparser 0.27.2",
- "derive_more 0.99.19",
+ "derive_more 0.99.20",
  "fxhash",
  "log",
  "matches",
@@ -11797,7 +11830,7 @@ checksum = "5b75e048a93e14929e68e37b82e207db957cbb368375a80ed3ca28ac75080856"
 dependencies = [
  "bitflags 2.9.0",
  "cssparser 0.35.0",
- "derive_more 0.99.19",
+ "derive_more 0.99.20",
  "fxhash",
  "log",
  "new_debug_unreachable",
@@ -11810,15 +11843,6 @@ dependencies = [
  "to_shmem_derive",
 ]
 
-[[package]]
-name = "semver"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser",
-]
-
 [[package]]
 name = "semver"
 version = "1.0.26"
@@ -11828,12 +11852,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "semver-parser"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-
 [[package]]
 name = "send_wrapper"
 version = "0.6.0"
@@ -11900,7 +11918,7 @@ checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11944,7 +11962,7 @@ checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -11995,7 +12013,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -12058,7 +12076,7 @@ dependencies = [
  "convert_case 0.6.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "xxhash-rust",
 ]
 
@@ -12069,7 +12087,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eb8b274f568c94226a8045668554aace8142a59b8bca5414ac5a79627c825568"
 dependencies = [
  "server_fn_macro",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -12185,9 +12203,9 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.2"
+version = "1.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
+checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410"
 dependencies = [
  "libc",
 ]
@@ -12208,7 +12226,7 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9cadb29c57caadc51ff8346233b5cec1d240b68ce55cf1afc764818791876987"
 dependencies = [
- "outref",
+ "outref 0.1.0",
 ]
 
 [[package]]
@@ -12290,12 +12308,12 @@ dependencies = [
 
 [[package]]
 name = "sledgehammer_bindgen_macro"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33a1b4f13e2bbf2f5b29d09dfebc9de69229ffee245aed80e3b70f9b5fd28c06"
+checksum = "f62f06db0370222f7f498ef478fce9f8df5828848d1d3517e3331936d7074f55"
 dependencies = [
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -12446,17 +12464,16 @@ dependencies = [
 
 [[package]]
 name = "sourcemap"
-version = "9.1.2"
+version = "9.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27c4ea7042fd1a155ad95335b5d505ab00d5124ea0332a06c8390d200bb1a76a"
+checksum = "dd430118acc9fdd838557649b9b43fd0a78e3834d84a283b466f8e84720d6101"
 dependencies = [
- "base64-simd",
+ "base64-simd 0.8.0",
  "bitvec",
  "data-encoding",
  "debugid",
  "if_chain",
- "rustc-hash 1.1.0",
- "rustc_version 0.2.3",
+ "rustc-hash 2.1.1",
  "serde",
  "serde_json",
  "unicode-id-start",
@@ -12744,9 +12761,9 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "stacker"
-version = "0.1.20"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "601f9201feb9b09c00266478bf459952b9ef9a6b94edb2f21eba14ab681a60a9"
+checksum = "cddb07e32ddb770749da91081d8d0ac3a16f1a569a18b20348cd371f5dead06b"
 dependencies = [
  "cc",
  "cfg-if",
@@ -12826,7 +12843,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "swc_macros_common",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -12884,7 +12901,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -12899,7 +12916,7 @@ dependencies = [
  "bitflags 2.9.0",
  "byteorder",
  "cssparser 0.35.0",
- "derive_more 0.99.19",
+ "derive_more 0.99.20",
  "encoding_rs",
  "euclid",
  "fxhash",
@@ -12971,7 +12988,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "synstructure 0.13.1",
 ]
 
@@ -13077,9 +13094,9 @@ dependencies = [
 
 [[package]]
 name = "svg_fmt"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce5d813d71d82c4cbc1742135004e4a79fd870214c155443451c139c9470a0aa"
+checksum = "0193cc4331cfd2f3d2011ef287590868599a2f33c3e69bc22c1a3d3acf9e02fb"
 
 [[package]]
 name = "svgtypes"
@@ -13222,7 +13239,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "swc_macros_common",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -13273,7 +13290,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "swc_macros_common",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -13388,7 +13405,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "swc_macros_common",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -13475,7 +13492,7 @@ checksum = "e96e15288bf385ab85eb83cff7f9e2d834348da58d0a31b33bdb572e66ee413e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -13511,7 +13528,7 @@ checksum = "a509f56fca05b39ba6c15f3e58636c3924c78347d63853632ed2ffcb6f5a0ac7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -13555,9 +13572,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.100"
+version = "2.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -13599,7 +13616,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -13686,9 +13703,9 @@ dependencies = [
 
 [[package]]
 name = "taffy"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56a844965df28147d726ecc321bf67f287a9bdec5a655f53d4e7e5cad20443dc"
+checksum = "592835b1f82a500b55aa6242e5e2d1fb90c50e701fa9c33b5962d4aeaa4e88d6"
 dependencies = [
  "arrayvec",
  "grid",
@@ -13744,7 +13761,7 @@ checksum = "f4e16beb8b2ac17db28eab8bca40e62dbfbb34c0fcdc6d9826b11b7b5d047dfd"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -13805,7 +13822,7 @@ dependencies = [
  "plist",
  "regex",
  "rpm",
- "semver 1.0.26",
+ "semver",
  "serde",
  "serde_json",
  "sha1",
@@ -13877,7 +13894,7 @@ dependencies = [
  "memchr",
  "phf 0.11.3",
  "regex",
- "semver 1.0.26",
+ "semver",
  "serde",
  "serde-untagged",
  "serde_json",
@@ -13980,7 +13997,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -13991,7 +14008,7 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -14159,7 +14176,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "synstructure 0.13.1",
 ]
 
@@ -14200,7 +14217,7 @@ checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -14229,7 +14246,7 @@ version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e727b36a1a0e8b74c376ac2211e40c2c8af09fb4013c60d910495810f008e9b"
 dependencies = [
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "tokio",
 ]
 
@@ -14254,7 +14271,7 @@ dependencies = [
  "futures-util",
  "log",
  "native-tls",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "tokio",
  "tokio-native-tls",
  "tungstenite 0.23.0",
@@ -14274,16 +14291,16 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.14"
+version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b9590b93e6fcc1739458317cccd391ad3955e2bde8913edf6f95f9e65a8f034"
+checksum = "66a539a9ad6d5d281510d5bd368c973d636c02dbf8a67300bfb6b950696ad7df"
 dependencies = [
  "bytes",
  "futures-core",
  "futures-io",
  "futures-sink",
  "futures-util",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.2",
  "pin-project-lite",
  "slab",
  "tokio",
@@ -14291,22 +14308,22 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.20"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd87a5cdd6ffab733b2f74bc4fd7ee5fff6634124999ac278c35fc78c6120148"
+checksum = "05ae329d1f08c4d17a59bed7ff5b5a769d062e64a62d34a3261b219e62cd5aae"
 dependencies = [
  "indexmap 2.9.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit 0.22.24",
+ "toml_edit 0.22.26",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.8"
+version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
+checksum = "3da5db5a963e24bc68be8b17b6fa82814bb22ee8660f192bb182771d498f09a3"
 dependencies = [
  "serde",
 ]
@@ -14335,17 +14352,24 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.22.24"
+version = "0.22.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b4795ff5edd201c7cd6dca065ae59972ce77d1b80fa0a84d94950ece7d1474"
+checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
 dependencies = [
  "indexmap 2.9.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
- "winnow 0.7.6",
+ "toml_write",
+ "winnow 0.7.7",
 ]
 
+[[package]]
+name = "toml_write"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfb942dfe1d8e29a7ee7fcbde5bd2b9a25fb89aa70caea2eba3bee836ff41076"
+
 [[package]]
 name = "tonic"
 version = "0.11.0"
@@ -14472,7 +14496,7 @@ checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -14569,11 +14593,11 @@ dependencies = [
  "dirs 6.0.0",
  "libappindicator",
  "muda 0.15.3",
- "objc2 0.6.0",
- "objc2-app-kit 0.3.0",
+ "objc2 0.6.1",
+ "objc2-app-kit 0.3.1",
  "objc2-core-foundation",
  "objc2-core-graphics",
- "objc2-foundation 0.3.0",
+ "objc2-foundation 0.3.1",
  "once_cell",
  "png",
  "thiserror 2.0.12",
@@ -14976,11 +15000,11 @@ dependencies = [
  "base64 0.22.1",
  "log",
  "once_cell",
- "rustls 0.23.25",
+ "rustls 0.23.26",
  "rustls-pki-types",
  "socks",
  "url",
- "webpki-roots 0.26.8",
+ "webpki-roots 0.26.9",
 ]
 
 [[package]]
@@ -15190,6 +15214,12 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
 
+[[package]]
+name = "vsimd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -15226,7 +15256,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -15257,7 +15287,7 @@ checksum = "59195a1db0e95b920366d949ba5e0d3fc0e70b67c09be15ce5abb790106b0571"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -15309,7 +15339,7 @@ dependencies = [
  "log",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "wasm-bindgen-shared",
 ]
 
@@ -15344,7 +15374,7 @@ checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -15379,7 +15409,7 @@ checksum = "17d5042cc5fa009658f9a7333ef24291b1291a25b6382dd68862a7f3b969f69b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -15474,7 +15504,7 @@ dependencies = [
  "dioxus",
  "dioxus-router",
  "futures",
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "js-sys",
  "once_cell",
  "reqwest 0.12.15",
@@ -15492,7 +15522,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "sha2",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -15527,7 +15557,7 @@ dependencies = [
  "bitflags 2.9.0",
  "hashbrown 0.14.5",
  "indexmap 2.9.0",
- "semver 1.0.26",
+ "semver",
  "serde",
 ]
 
@@ -15549,7 +15579,7 @@ dependencies = [
  "bitflags 2.9.0",
  "hashbrown 0.15.2",
  "indexmap 2.9.0",
- "semver 1.0.26",
+ "semver",
  "serde",
 ]
 
@@ -15561,14 +15591,14 @@ checksum = "0cc3b1f053f5d41aa55640a1fa9b6d1b8a9e4418d118ce308d20e24ff3575a8c"
 dependencies = [
  "bitflags 2.9.0",
  "indexmap 2.9.0",
- "semver 1.0.26",
+ "semver",
 ]
 
 [[package]]
 name = "wayland-backend"
-version = "0.3.8"
+version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7208998eaa3870dad37ec8836979581506e0c5c64c20c9e79e9d2a10d6f47bf"
+checksum = "fe770181423e5fc79d3e2a7f4410b7799d5aab1de4372853de3c6aa13ca24121"
 dependencies = [
  "cc",
  "downcast-rs",
@@ -15580,9 +15610,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-client"
-version = "0.31.8"
+version = "0.31.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2120de3d33638aaef5b9f4472bff75f07c56379cf76ea320bd3a3d65ecaf73f"
+checksum = "978fa7c67b0847dbd6a9f350ca2569174974cd4082737054dbb7fbb79d7d9a61"
 dependencies = [
  "bitflags 2.9.0",
  "rustix 0.38.44",
@@ -15603,9 +15633,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-cursor"
-version = "0.31.8"
+version = "0.31.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a93029cbb6650748881a00e4922b076092a6a08c11e7fbdb923f064b23968c5d"
+checksum = "a65317158dec28d00416cb16705934070aef4f8393353d41126c54264ae0f182"
 dependencies = [
  "rustix 0.38.44",
  "wayland-client",
@@ -15614,9 +15644,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols"
-version = "0.32.6"
+version = "0.32.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0781cf46869b37e36928f7b432273c0995aa8aed9552c556fb18754420541efc"
+checksum = "779075454e1e9a521794fed15886323ea0feda3f8b0fc1390f5398141310422a"
 dependencies = [
  "bitflags 2.9.0",
  "wayland-backend",
@@ -15626,9 +15656,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols-plasma"
-version = "0.3.6"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ccaacc76703fefd6763022ac565b590fcade92202492381c95b2edfdf7d46b3"
+checksum = "4fd38cdad69b56ace413c6bcc1fbf5acc5e2ef4af9d5f8f1f9570c0c83eae175"
 dependencies = [
  "bitflags 2.9.0",
  "wayland-backend",
@@ -15639,9 +15669,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols-wlr"
-version = "0.3.6"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "248a02e6f595aad796561fa82d25601bd2c8c3b145b1c7453fc8f94c1a58f8b2"
+checksum = "1cb6cdc73399c0e06504c437fe3cf886f25568dd5454473d565085b36d6a8bbf"
 dependencies = [
  "bitflags 2.9.0",
  "wayland-backend",
@@ -15657,7 +15687,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "896fdafd5d28145fce7958917d69f2fd44469b1d4e861cb5961bcbeebc6d1484"
 dependencies = [
  "proc-macro2",
- "quick-xml 0.37.4",
+ "quick-xml 0.37.5",
  "quote",
 ]
 
@@ -15762,9 +15792,9 @@ checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
 [[package]]
 name = "webpki-roots"
-version = "0.26.8"
+version = "0.26.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2210b291f7ea53617fbafcc4939f10914214ec15aace5ba62293a668f322c5c9"
+checksum = "29aad86cec885cafd03e8305fd727c418e970a521322c91688414d5b8efba16b"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -15791,7 +15821,7 @@ checksum = "1d228f15bba3b9d56dde8bddbee66fa24545bd17b48d5128ccf4a8742b18e431"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -16038,13 +16068,13 @@ dependencies = [
 
 [[package]]
 name = "which"
-version = "7.0.2"
+version = "7.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2774c861e1f072b3aadc02f8ba886c26ad6321567ecc294c935434cad06f1283"
+checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762"
 dependencies = [
  "either",
  "env_home",
- "rustix 0.38.44",
+ "rustix 1.0.5",
  "winsafe",
 ]
 
@@ -16247,7 +16277,7 @@ checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -16258,7 +16288,7 @@ checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -16269,7 +16299,7 @@ checksum = "83577b051e2f49a058c308f17f273b570a6a758386fc291b5f6a934dd84e48c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -16280,7 +16310,7 @@ checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -16291,7 +16321,7 @@ checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -16302,7 +16332,7 @@ checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -16313,7 +16343,7 @@ checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -16687,9 +16717,9 @@ checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
 
 [[package]]
 name = "winit"
-version = "0.30.9"
+version = "0.30.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a809eacf18c8eca8b6635091543f02a5a06ddf3dad846398795460e6e0ae3cc0"
+checksum = "b0d05bd8908e14618c9609471db04007e644fd9cce6529756046cfc577f9155e"
 dependencies = [
  "ahash 0.8.11",
  "android-activity",
@@ -16757,9 +16787,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.7.6"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63d3fcd9bba44b03821e7d699eeee959f3126dcc4aa8e4ae18ec617c2a5cea10"
+checksum = "6cb8234a863ea0e8cd7284fcdd4f145233eb00fee02bbdd9861aec44e6477bc5"
 dependencies = [
  "memchr",
 ]
@@ -16808,7 +16838,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b19b78efae8b853c6c817e8752fc1dbf9cab8a8ffe9c30f399bd750ccf0f0730"
 dependencies = [
  "base64 0.22.1",
- "block2 0.6.0",
+ "block2 0.6.1",
  "cookie",
  "crossbeam-channel",
  "dpi",
@@ -16822,11 +16852,11 @@ dependencies = [
  "kuchikiki",
  "libc",
  "ndk",
- "objc2 0.6.0",
- "objc2-app-kit 0.3.0",
+ "objc2 0.6.1",
+ "objc2-app-kit 0.3.1",
  "objc2-core-foundation",
- "objc2-foundation 0.3.0",
- "objc2-ui-kit 0.3.0",
+ "objc2-foundation 0.3.1",
+ "objc2-ui-kit 0.3.1",
  "objc2-web-kit",
  "once_cell",
  "percent-encoding",
@@ -16995,9 +17025,9 @@ checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56"
 
 [[package]]
 name = "xml-rs"
-version = "0.8.25"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5b940ebc25896e71dd073bad2dbaa2abfe97b0a391415e22ad1326d9c54e3c4"
+checksum = "a62ce76d9b56901b19a74f19431b0d8b3bc7ca4ad685a746dfd78ca8f4fc6bda"
 
 [[package]]
 name = "xmlwriter"
@@ -17058,7 +17088,7 @@ checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "synstructure 0.13.1",
 ]
 
@@ -17119,7 +17149,7 @@ checksum = "709ab20fc57cb22af85be7b360239563209258430bccf38d8b979c5a2ae3ecce"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "zbus-lockstep",
  "zbus_xml",
  "zvariant",
@@ -17134,7 +17164,7 @@ dependencies = [
  "proc-macro-crate 3.3.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "zvariant_utils",
 ]
 
@@ -17179,11 +17209,11 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.24"
+version = "0.8.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2586fea28e186957ef732a5f8b3be2da217d65c5969d4b1e17f973ebbe876879"
+checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb"
 dependencies = [
- "zerocopy-derive 0.8.24",
+ "zerocopy-derive 0.8.25",
 ]
 
 [[package]]
@@ -17194,18 +17224,18 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.24"
+version = "0.8.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be"
+checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -17225,7 +17255,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "synstructure 0.13.1",
 ]
 
@@ -17246,7 +17276,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -17268,7 +17298,7 @@ checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -17311,15 +17341,13 @@ dependencies = [
 
 [[package]]
 name = "zopfli"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5019f391bac5cf252e93bbcc53d039ffd62c7bfb7c150414d61369afe57e946"
+checksum = "edfc5ee405f504cd4984ecc6f14d02d55cfda60fa4b689434ef4102aae150cd7"
 dependencies = [
  "bumpalo",
  "crc32fast",
- "lockfree-object-pool",
  "log",
- "once_cell",
  "simd-adler32",
 ]
 
@@ -17398,7 +17426,7 @@ dependencies = [
  "proc-macro-crate 3.3.0",
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
  "zvariant_utils",
 ]
 
@@ -17410,5 +17438,5 @@ checksum = "c51bcff7cc3dbb5055396bcf774748c3dab426b4b8659046963523cee4808340"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 2.0.101",
 ]
diff --git a/packages/cli-opt/src/hash.rs b/packages/cli-opt/src/hash.rs
index 2fc8e080dc..15633c1f5d 100644
--- a/packages/cli-opt/src/hash.rs
+++ b/packages/cli-opt/src/hash.rs
@@ -1,7 +1,7 @@
 //! Utilities for creating hashed paths to assets in Manganis. This module defines [`AssetHash`] which is used to create a hashed path to an asset in both the CLI and the macro.
 
 use std::{
-    hash::Hasher,
+    hash::{Hash, Hasher},
     io::Read,
     path::{Path, PathBuf},
 };
@@ -46,6 +46,7 @@ impl AssetHash {
 fn hash_file(options: &AssetOptions, source: &Path) -> anyhow::Result<AssetHash> {
     // Create a hasher
     let mut hash = std::collections::hash_map::DefaultHasher::new();
+    options.hash(&mut hash);
     hash_file_with_options(options, source, &mut hash, false)?;
 
     let hash = hash.finish();
diff --git a/packages/cli/src/build/bundle.rs b/packages/cli/src/build/bundle.rs
index 37a4a28e52..e010ef54ce 100644
--- a/packages/cli/src/build/bundle.rs
+++ b/packages/cli/src/build/bundle.rs
@@ -460,11 +460,12 @@ impl AppBundle {
         tokio::task::spawn_blocking(move || {
             optimize_all_assets(
                 assets_to_transfer,
-                |from, _, _| {
+                |from, to, _| {
                     let processing = started_processing.fetch_add(1, Ordering::SeqCst);
                     let from_ = from.strip_prefix(&ws_dir).unwrap_or(from);
+                    let to_ = to.strip_prefix(&ws_dir).unwrap_or(to);
                     tracing::trace!(
-                        "Starting asset copy {processing}/{asset_count} from {from_:?}"
+                        "Starting asset copy {processing}/{asset_count} from {from_:?} to {to_:?}"
                     );
                 },
                 |from, _, _| {
diff --git a/packages/cli/src/cli/link.rs b/packages/cli/src/cli/link.rs
index cee81d088c..eade8fbb95 100644
--- a/packages/cli/src/cli/link.rs
+++ b/packages/cli/src/cli/link.rs
@@ -53,7 +53,7 @@ impl LinkAction {
         let log_file = std::fs::File::options()
             .append(true)
             .create(true)
-            .open("/Users/evanalmloff/Desktop/Github/dioxus-test/linker_logs.txt")
+            .open(linker_log_file())
             .unwrap();
         tracing_subscriber::fmt()
             .with_writer(log_file)
@@ -179,7 +179,7 @@ impl LinkAction {
                 let err_file = std::fs::File::options()
                     .append(true)
                     .create(true)
-                    .open("/Users/evanalmloff/Desktop/Github/dioxus-test/linker_err.txt")
+                    .open(linker_error_file())
                     .unwrap();
                 let toolchain = if targeting_wasm {
                     "stable-wasm32-unknown-unknown".to_string()
@@ -202,6 +202,21 @@ impl LinkAction {
     }
 }
 
+fn out_dir() -> PathBuf {
+    // let out_dir = std::env::var("OUT_DIR").unwrap();
+    // let out_dir = PathBuf::from(out_dir);
+    // out_dir
+    PathBuf::from("/Users/evanalmloff/Desktop/Github/dioxus-test")
+}
+
+fn linker_log_file() -> PathBuf {
+    out_dir().join("linker_log.txt")
+}
+
+fn linker_error_file() -> PathBuf {
+    out_dir().join("linker_error.txt")
+}
+
 struct AssetReference {
     file: PathBuf,
     offset: usize,
@@ -331,34 +346,31 @@ fn create_data_object_file<'a>(
     };
 
     let mut linking = LinkingSection::new();
-
     let mut sym_tab = SymbolTable::new();
-
     let mut data_section = DataSection::new();
-    let memory_index = 0;
 
+    let memory_index = 0;
     let mut offset = 0;
+    let mut all_bytes = Vec::new();
+
     for (symbol_name, data) in data_sections {
         let flags = SymbolTable::WASM_SYM_EXPORTED;
-        let index = 0;
         let size = data.len() as u32;
-        data_section.active(
-            memory_index,
-            &ConstExpr::i32_const(offset as i32),
-            data.iter().copied(),
-        );
+
+        all_bytes.extend_from_slice(&data);
         sym_tab.data(
             flags,
             symbol_name,
             Some(DataSymbolDefinition {
-                index,
-                offset,
+                index: memory_index,
+                offset: offset as u32,
                 size,
             }),
         );
         linking.symbol_table(&sym_tab);
-        offset += size;
+        offset += data.len();
     }
+    data_section.active(memory_index, &ConstExpr::i32_const(0), all_bytes);
 
     // Add the linking section to a new Wasm module and get the encoded bytes.
     let mut module = Module::new();
diff --git a/packages/const-serialize/src/const_vec.rs b/packages/const-serialize/src/const_vec.rs
index 5535b31a1d..888526530f 100644
--- a/packages/const-serialize/src/const_vec.rs
+++ b/packages/const-serialize/src/const_vec.rs
@@ -420,3 +420,17 @@ fn test_const_vec_remove() {
     assert_eq!(value, Some(5678));
     assert_eq!(vec.as_ref(), &[]);
 }
+
+#[test]
+fn test_const_vec_extend() {
+    const VEC: ConstVec<u32> = {
+        let mut vec = ConstVec::new();
+        vec = vec.push(1234);
+        vec = vec.push(5678);
+        vec = vec.extend(&[91011, 1213]);
+        vec
+    };
+    let vec = VEC;
+    println!("{:?}", vec);
+    assert_eq!(vec.as_ref(), &[1234, 5678, 91011, 1213]);
+}
diff --git a/packages/const-serialize/tests/enum.rs b/packages/const-serialize/tests/enum.rs
index 130a5dbaa0..a0df9f160c 100644
--- a/packages/const-serialize/tests/enum.rs
+++ b/packages/const-serialize/tests/enum.rs
@@ -95,6 +95,67 @@ fn test_serialize_enum() {
     assert_eq!(deserialize_const!(Enum, buf).unwrap().1, data);
 }
 
+#[test]
+fn test_serialize_list_of_lopsided_enums() {
+    #[derive(Clone, Copy, Debug, PartialEq, SerializeConst)]
+    #[repr(C, u8)]
+    enum Enum {
+        A,
+        B { one: u8, two: u16 } = 15,
+    }
+
+    println!("{:#?}", Enum::MEMORY_LAYOUT);
+
+    let data = [Enum::A, Enum::A];
+    let mut buf = ConstVec::new();
+    buf = serialize_const(&data, buf);
+    println!("{:?}", buf.as_ref());
+    let buf = buf.read();
+    assert_eq!(deserialize_const!([Enum; 2], buf).unwrap().1, data);
+
+    let data = [
+        Enum::B {
+            one: 0x11,
+            two: 0x2233,
+        },
+        Enum::B {
+            one: 0x12,
+            two: 0x2244,
+        },
+    ];
+    let mut buf = ConstVec::new();
+    buf = serialize_const(&data, buf);
+    println!("{:?}", buf.as_ref());
+    let buf = buf.read();
+    assert_eq!(deserialize_const!([Enum; 2], buf).unwrap().1, data);
+
+    let data = [
+        Enum::A,
+        Enum::B {
+            one: 0x11,
+            two: 0x2233,
+        },
+    ];
+    let mut buf = ConstVec::new();
+    buf = serialize_const(&data, buf);
+    println!("{:?}", buf.as_ref());
+    let buf = buf.read();
+    assert_eq!(deserialize_const!([Enum; 2], buf).unwrap().1, data);
+
+    let data = [
+        Enum::B {
+            one: 0x11,
+            two: 0x2233,
+        },
+        Enum::A,
+    ];
+    let mut buf = ConstVec::new();
+    buf = serialize_const(&data, buf);
+    println!("{:?}", buf.as_ref());
+    let buf = buf.read();
+    assert_eq!(deserialize_const!([Enum; 2], buf).unwrap().1, data);
+}
+
 #[test]
 fn test_serialize_u8_enum() {
     #[derive(Clone, Copy, Debug, PartialEq, SerializeConst)]
diff --git a/packages/manganis/manganis-core/src/asset.rs b/packages/manganis/manganis-core/src/asset.rs
index d783d1378d..487a16db5f 100644
--- a/packages/manganis/manganis-core/src/asset.rs
+++ b/packages/manganis/manganis-core/src/asset.rs
@@ -1,24 +1,13 @@
 use crate::AssetOptions;
 use const_serialize::{deserialize_const, ConstStr, ConstVec, SerializeConst};
-use std::{fmt::Debug, path::PathBuf};
+use std::{fmt::Debug, hash::Hash, path::PathBuf};
 
 /// An asset that should be copied by the bundler with some options. This type will be
 /// serialized into the binary and added to the link section [`LinkSection::CURRENT`](crate::linker::LinkSection::CURRENT).
 /// CLIs that support manganis, should pull out the assets from the link section, optimize,
 /// and write them to the filesystem at [`BundledAsset::bundled_path`] for the application
 /// to use.
-#[derive(
-    Debug,
-    Eq,
-    PartialEq,
-    PartialOrd,
-    Clone,
-    Copy,
-    Hash,
-    SerializeConst,
-    serde::Serialize,
-    serde::Deserialize,
-)]
+#[derive(Debug, Eq, Clone, Copy, SerializeConst, serde::Serialize, serde::Deserialize)]
 pub struct BundledAsset {
     /// The absolute path of the asset
     absolute_source_path: ConstStr,
@@ -30,6 +19,39 @@ pub struct BundledAsset {
     link_section: ConstStr,
 }
 
+impl PartialEq for BundledAsset {
+    fn eq(&self, other: &Self) -> bool {
+        self.absolute_source_path == other.absolute_source_path
+            && self.bundled_path == other.bundled_path
+            && self.options == other.options
+    }
+}
+
+impl PartialOrd for BundledAsset {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        match self
+            .absolute_source_path
+            .partial_cmp(&other.absolute_source_path)
+        {
+            Some(core::cmp::Ordering::Equal) => {}
+            ord => return ord,
+        }
+        match self.bundled_path.partial_cmp(&other.bundled_path) {
+            Some(core::cmp::Ordering::Equal) => {}
+            ord => return ord,
+        }
+        self.options.partial_cmp(&other.options)
+    }
+}
+
+impl Hash for BundledAsset {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.absolute_source_path.hash(state);
+        self.bundled_path.hash(state);
+        self.options.hash(state);
+    }
+}
+
 impl BundledAsset {
     #[doc(hidden)]
     /// This should only be called from the macro
@@ -148,7 +170,7 @@ impl Asset {
             bytes = bytes.push(unsafe { std::ptr::read_volatile(ptr.add(byte)) });
         }
         let read = bytes.read();
-        deserialize_const!(BundledAsset, read).unwrap().1
+        deserialize_const!(BundledAsset, read).expect("Failed to deserialize asset. Make sure you built with the matching version of the Dioxus CLI").1
     }
 
     /// Return a canonicalized path to the asset
diff --git a/packages/manganis/manganis-macro/src/asset.rs b/packages/manganis/manganis-macro/src/asset.rs
index c0730a6eea..f1818e0d4e 100644
--- a/packages/manganis/manganis-macro/src/asset.rs
+++ b/packages/manganis/manganis-macro/src/asset.rs
@@ -146,8 +146,9 @@ impl ToTokens for AssetParser {
 
         let mut hash = DefaultHasher::new();
         format!("{:?}", self.options.span()).hash(&mut hash);
+        format!("{:?}", self.options.to_string()).hash(&mut hash);
         asset_string.hash(&mut hash);
-        let asset_hash = format!("__MANGANIS_ASSET_{:x}", hash.finish());
+        let asset_hash = format!("__MANGANIS_ASSET_{:016x}", hash.finish());
 
         // Generate the link section for the asset
         // The link section includes the source path and the output path of the asset

From d232eada0945cb7179597ccf08f27febcc709e66 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Wed, 30 Apr 2025 13:48:09 -0500
Subject: [PATCH 10/11] add a regression test for 3467

---
 .../playwright-tests/cli-optimization.spec.js     | 15 +++++++++++++++
 .../playwright-tests/cli-optimization/src/main.rs |  7 +++++++
 .../playwright-tests/test-results/.last-run.json  |  8 --------
 3 files changed, 22 insertions(+), 8 deletions(-)
 delete mode 100644 packages/playwright-tests/test-results/.last-run.json

diff --git a/packages/playwright-tests/cli-optimization.spec.js b/packages/playwright-tests/cli-optimization.spec.js
index a4678bff93..50d7ffcbfa 100644
--- a/packages/playwright-tests/cli-optimization.spec.js
+++ b/packages/playwright-tests/cli-optimization.spec.js
@@ -8,4 +8,19 @@ test("optimized scripts run", async ({ page }) => {
   // should add an editor to the page that shows a main function
   const main = page.locator("#main");
   await expect(main).toContainText("hi");
+
+  // Expect the page to contain an image with the id "some_image"
+  const image = page.locator("#some_image");
+  await expect(image).toBeVisible();
+  // Get the image src
+  const src = await image.getAttribute("src");
+
+  // Expect the page to contain an image with the id "some_image_with_the_same_url"
+  const image2 = page.locator("#some_image_with_the_same_url");
+  await expect(image2).toBeVisible();
+  // Get the image src
+  const src2 = await image2.getAttribute("src");
+
+  // Expect the urls to be different
+  expect(src).not.toEqual(src2);
 });
diff --git a/packages/playwright-tests/cli-optimization/src/main.rs b/packages/playwright-tests/cli-optimization/src/main.rs
index a216497178..f2c50b570d 100644
--- a/packages/playwright-tests/cli-optimization/src/main.rs
+++ b/packages/playwright-tests/cli-optimization/src/main.rs
@@ -4,6 +4,8 @@ use dioxus::prelude::*;
 
 const MONACO_FOLDER: Asset = asset!("/monaco-editor-0.52.2/package/min/vs");
 const SOME_IMAGE: Asset = asset!("/images/toasts.png", ImageAssetOptions::new().with_avif());
+const SOME_IMAGE_WITH_THE_SAME_URL: Asset =
+    asset!("/images/toasts.png", ImageAssetOptions::new().with_jpeg());
 
 fn main() {
     dioxus::launch(App);
@@ -32,7 +34,12 @@ fn App() -> Element {
             "onload": script
         }
         img {
+            id: "some_image",
             src: "{SOME_IMAGE}"
         }
+        img {
+            id: "some_image_with_the_same_url",
+            src: "{SOME_IMAGE_WITH_THE_SAME_URL}"
+        }
     }
 }
diff --git a/packages/playwright-tests/test-results/.last-run.json b/packages/playwright-tests/test-results/.last-run.json
deleted file mode 100644
index 02f9f17861..0000000000
--- a/packages/playwright-tests/test-results/.last-run.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "status": "interrupted",
-  "failedTests": [
-    "d630e8b735ec4c8447b5-3853da72eac8a6a9a3b7",
-    "ff750809a07139231c1d-e791c1c230e601a8bc52",
-    "7d44990a3cf257f22406-5c4d478bb363aff6da09"
-  ]
-}
\ No newline at end of file

From 59d2ef099a71d7028ffa64a6d29fac2d42008f14 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Wed, 30 Apr 2025 13:54:47 -0500
Subject: [PATCH 11/11] fix image link

---
 packages/playwright-tests/cli-optimization/src/main.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/playwright-tests/cli-optimization/src/main.rs b/packages/playwright-tests/cli-optimization/src/main.rs
index f2c50b570d..d0301434ba 100644
--- a/packages/playwright-tests/cli-optimization/src/main.rs
+++ b/packages/playwright-tests/cli-optimization/src/main.rs
@@ -5,7 +5,7 @@ use dioxus::prelude::*;
 const MONACO_FOLDER: Asset = asset!("/monaco-editor-0.52.2/package/min/vs");
 const SOME_IMAGE: Asset = asset!("/images/toasts.png", ImageAssetOptions::new().with_avif());
 const SOME_IMAGE_WITH_THE_SAME_URL: Asset =
-    asset!("/images/toasts.png", ImageAssetOptions::new().with_jpeg());
+    asset!("/images/toasts.png", ImageAssetOptions::new().with_jpg());
 
 fn main() {
     dioxus::launch(App);