feat: Add Desync hash detection via DesyncHash trait, opt in with #[net] attribute

Cargo.toml

@@ -27,6 +27,7 @@ fxhash       = "0.2"
 hashbrown    = "0.14"
 maybe-owned  = "0.3"
 parking_lot  = "0.12"
+serde_json   = "1"
 smallvec     = "1.11"
 ustr         = "0.10"
 iroh-net     = "0.27"

framework_crates/bones_asset/Cargo.toml

@@ -37,7 +37,7 @@ paste           = "1.0"
 path-absolutize = { version = "3.1", features = ["use_unix_paths_on_wasm"] }
 semver          = { version = "1.0", features = ["serde"] }
 serde           = { version = "1.0", features = ["derive"] }
-serde_json      = "1.0"
+serde_json      = { workspace = true }
 serde_yaml      = "0.9"
 sha2            = "0.10"
 tracing         = "0.1"

framework_crates/bones_asset/src/lib.rs

@@ -5,6 +5,7 @@
 #![cfg_attr(doc, allow(unknown_lints))]
 #![deny(rustdoc::all)]
 
+use bones_utils::DesyncHash;
 use serde::{de::DeserializeSeed, Deserializer};
 
 /// Helper to export the same types in the crate root and in the prelude.
@@ -282,6 +283,18 @@ impl<T> From<Option<T>> for Maybe<T> {
     }
 }
 
+impl<T: DesyncHash> DesyncHash for Maybe<T> {
+    fn hash(&self, hasher: &mut dyn std::hash::Hasher) {
+        match self {
+            Maybe::Unset => 0.hash(hasher),
+            Maybe::Set(value) => {
+                1.hash(hasher);
+                value.hash(hasher)
+            }
+        }
+    }
+}
+
 fn maybe_loader(
     ctx: &mut MetaAssetLoadCtx,
     ptr: SchemaRefMut<'_>,

framework_crates/bones_ecs/Cargo.toml

@@ -14,7 +14,7 @@ keywords.workspace      = true
 default = ["derive", "keysize16"]
 miri    = ["derive", "keysize10"]
 derive  = ["dep:bones_ecs_macros"]
-glam    = ["dep:glam", "dep:paste", "bones_schema/glam"]
+glam    = ["dep:glam", "dep:paste", "bones_schema/glam", "bones_utils/glam"]
 serde   = ["dep:serde"]
 
 keysize10 = []
@@ -36,6 +36,7 @@ serde            = { version = "1", features = ["derive"], optional = true }
 
 anyhow      = "1.0"
 branches    = { workspace = true }
+fxhash      = { workspace = true }
 atomicell   = "0.2"
 bitset-core = "0.1"
 once_map    = "0.4.12"

framework_crates/bones_ecs/src/components.rs

@@ -1,5 +1,6 @@
 //! ECS component storage.
 
+use fxhash::FxHasher;
 use once_map::OnceMap;
 use std::sync::Arc;
 
@@ -47,6 +48,114 @@ impl Clone for ComponentStores {
     }
 }
 
+impl DesyncHash for ComponentStores {
+    fn hash(&self, hasher: &mut dyn std::hash::Hasher) {
+        // Compute child hashes and sort
+        let mut hashes = self
+            .components
+            .read_only_view()
+            .iter()
+            .filter_map(|(_, component_store)| {
+                // Verify Schema for component store implement desync hash. If no hash_fn, we don't
+                // want to add hash.
+                let component_store = component_store.as_ref().borrow();
+                if component_store
+                    .schema()
+                    .type_data
+                    .get::<SchemaDesyncHash>()
+                    .is_some()
+                {
+                    // We need to compute hashes first
+                    return Some(component_store.compute_hash::<FxHasher>());
+                }
+
+                None
+            })
+            .collect::<Vec<u64>>();
+        hashes.sort();
+
+        // Udpate parent hasher from sorted hashes
+        for hash in hashes.iter() {
+            hash.hash(hasher);
+        }
+    }
+}
+
+impl BuildDesyncNode for ComponentStores {
+    fn desync_tree_node<H: std::hash::Hasher + Default>(
+        &self,
+        include_unhashable: bool,
+    ) -> DefaultDesyncTreeNode {
+        let mut any_hashable = false;
+
+        // We get the Name component store so we can lookup entity names and set those on component leaves.
+        let names = self.get::<Name>().borrow();
+
+        let mut child_nodes = self
+            .components
+            .read_only_view()
+            .iter()
+            .filter_map(|(_, component_store)| {
+                let component_store = component_store.as_ref().borrow();
+                let is_hashable = component_store
+                    .schema()
+                    .type_data
+                    .get::<SchemaDesyncHash>()
+                    .is_some();
+
+                if is_hashable {
+                    any_hashable = true;
+                }
+
+                if include_unhashable || is_hashable {
+                    let mut child_node = component_store.desync_tree_node::<H>(include_unhashable);
+
+                    // Our child here is a component store, and its children are component leaves.
+                    // Iterate through children, retrieve metadata storing entity_idx if set, and use this
+                    // to update the node's name from Name component.
+                    //
+                    // This is fairly hacky, but should be good enough for now.
+                    for component_node in child_node.children_mut().iter_mut() {
+                        if let DesyncNodeMetadata::Component { entity_idx } =
+                            component_node.metadata()
+                        {
+                            // Constructing Entity with fake generation is bit of a hack - but component store does not
+                            // use generation, only the index.
+                            if let Some(name) = names.get(Entity::new(*entity_idx, 0)) {
+                                component_node.set_name(name.0.clone());
+                            }
+                        }
+                    }
+
+                    return Some(child_node);
+                }
+                None
+            })
+            .collect::<Vec<DefaultDesyncTreeNode>>();
+        child_nodes.sort();
+
+        let hash = if any_hashable {
+            let mut hasher = H::default();
+            for node in child_nodes.iter() {
+                // Update parent node hash from data
+                if let Some(hash) = node.get_hash() {
+                    DesyncHash::hash(&hash, &mut hasher);
+                }
+            }
+            Some(hasher.finish())
+        } else {
+            None
+        };
+
+        DefaultDesyncTreeNode::new(
+            hash,
+            Some("Components".into()),
+            child_nodes,
+            DesyncNodeMetadata::None,
+        )
+    }
+}
+
 impl ComponentStores {
     /// Get the components of a certain type
     pub fn get_cell<T: HasSchema>(&self) -> AtomicComponentStore<T> {

framework_crates/bones_ecs/src/components/untyped.rs

@@ -73,6 +73,69 @@ impl Drop for UntypedComponentStore {
     }
 }
 
+impl DesyncHash for UntypedComponentStore {
+    fn hash(&self, hasher: &mut dyn std::hash::Hasher) {
+        self.schema().full_name.hash(hasher);
+        for component in self.iter() {
+            DesyncHash::hash(&component, hasher);
+        }
+    }
+}
+
+impl BuildDesyncNode for UntypedComponentStore {
+    fn desync_tree_node<H: std::hash::Hasher + Default>(
+        &self,
+        _include_unhashable: bool,
+    ) -> DefaultDesyncTreeNode {
+        let mut hasher = H::default();
+
+        // Iterate over components by index so we can save entity ID.
+        let iter = 0..self.bitset().bit_len();
+        let child_nodes: Vec<DefaultDesyncTreeNode> = iter
+            .filter_map(|entity_idx| -> Option<DefaultDesyncTreeNode> {
+                if let Some(component) = self.get_idx(entity_idx) {
+                    let hash = if component
+                        .schema()
+                        .type_data
+                        .get::<SchemaDesyncHash>()
+                        .is_some()
+                    {
+                        // Update parent node hash from data
+                        DesyncHash::hash(&component, &mut hasher);
+                        Some(component.compute_hash::<H>())
+                    } else {
+                        None
+                    };
+
+                    return Some(DefaultDesyncTreeNode::new(
+                        hash,
+                        None,
+                        vec![],
+                        DesyncNodeMetadata::Component {
+                            entity_idx: entity_idx as u32,
+                        },
+                    ));
+                }
+
+                None
+            })
+            .collect();
+
+        let hash = if !child_nodes.is_empty() {
+            Some(hasher.finish())
+        } else {
+            None
+        };
+
+        DefaultDesyncTreeNode::new(
+            hash,
+            Some(self.schema().full_name.to_string()),
+            child_nodes,
+            DesyncNodeMetadata::None,
+        )
+    }
+}
+
 impl UntypedComponentStore {
     /// Create a arbitrary [`UntypedComponentStore`].
     ///

framework_crates/bones_ecs/src/entities.rs

@@ -85,6 +85,22 @@ impl Default for Entities {
     }
 }
 
+/// Utility component storing a name for entity
+#[derive(HasSchema, Clone, Debug)]
+pub struct Name(pub String);
+
+impl Default for Name {
+    fn default() -> Self {
+        Self("Unnamed".to_string())
+    }
+}
+
+impl From<&str> for Name {
+    fn from(value: &str) -> Self {
+        Self(value.into())
+    }
+}
+
 /// A type representing a component-joining entity query.
 pub trait QueryItem {
     /// The type of iterator this query item creates