check

Author: databasedav

Cargo.lock

@@ -65,6 +65,7 @@ deployed_wasm_example = []
 [dev-dependencies]
 bevy = "0.16"
 rand = "0.9"
+test-log = { version = "0.2", default-features = false, features = ["trace"] }
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies.getrandom]
 version = "0.3"

Cargo.toml

@@ -88,6 +88,7 @@ fn ui_root() -> JonmoBuilder {
             flex_direction: FlexDirection::Row,
             column_gap: Val::Px(15.0),
             align_items: AlignItems::Center,
+            padding: UiRect::all(Val::Px(25.)),
             ..default()
         })
         .insert(Counter(0))
@@ -117,7 +118,7 @@ fn ui_root() -> JonmoBuilder {
                         // `.dedupe()` ensures the rest of the chain only runs when the counter's value *actually
                         // changes*, preventing redundant updates every frame.
                         .dedupe()
-                        // `Text` expects a `String`
+                        // `Text` expects a `String` and `.to_string` expects a reference
                         .map_in_ref(ToString::to_string)
                         .map_in(Text)
                         // `component_signal` expects an `Option<Component>`. If the signal produces `None`, the

README.md

@@ -91,7 +91,7 @@ fn ui_root() -> JonmoBuilder {
                         // `.dedupe()` ensures the rest of the chain only runs when the counter's value *actually
                         // changes*, preventing redundant updates every frame.
                         .dedupe()
-                        // `Text` expects a `String`
+                        // `Text` expects a `String` and `.to_string` expects a reference
                         .map_in_ref(ToString::to_string)
                         .map_in(Text)
                         // `component_signal` expects an `Option<Component>`. If the signal produces `None`, the

examples/counter.rs

@@ -399,7 +399,7 @@ impl Clone for LazySignal {
 impl Drop for LazySignal {
     fn drop(&mut self) {
         // <= 2 because we also wna queue if only the holder remains
-        if self.inner.references.fetch_sub(1, Ordering::SeqCst) == 1
+        if self.inner.references.fetch_sub(1, Ordering::SeqCst) <= 2
             && let LazySystem::Registered(signal) = *self.inner.system.read().unwrap()
         {
             CLEANUP_SIGNALS.lock().unwrap().push(signal);
@@ -510,52 +510,54 @@ where
 }
 
 fn cleanup_recursive(world: &mut World, signal: SignalSystem) {
-    // Stage 1: Decrement the count and check if this node needs full cleanup.
+    // Stage 1: Decrement the count and check if this node needs full cleanup. We do
+    // this in a short-lived block to release the borrow.
     let mut needs_full_cleanup = false;
     if let Ok(mut entity) = world.get_entity_mut(*signal)
-        && let Some(mut count) = entity.get_mut::<SignalRegistrationCount>() {
-            count.decrement();
-            if **count == 0 {
-                needs_full_cleanup = true;
-            }
+        && let Some(mut count) = entity.get_mut::<SignalRegistrationCount>()
+    {
+        count.decrement();
+        if **count == 0 {
+            needs_full_cleanup = true;
         }
+    }
 
+    // If the count is not zero, we're done with this branch of the graph.
     if !needs_full_cleanup {
         return;
     }
 
-    // Stage 2: The count is zero. Get upstreams before we potentially despawn the entity.
+    // Stage 2: The count is zero. Perform the full cleanup. First, get the list of
+    // parents.
     let upstreams = world.get::<Upstream>(*signal).cloned();
 
-    // Stage 3: Despawn the current node if it's no longer needed.
+    // Now, we can despawn the current node if it's no longer needed. The check for
+    // LazySignalHolder is crucial.
     if let Ok(entity) = world.get_entity_mut(*signal) {
-        let should_despawn = if let Some(lazy_holder) = entity.get::<LazySignalHolder>() {
-            // This signal is held by a LazySignal. It can only be despawned if the
-            // only remaining reference is the one inside this holder component.
-            lazy_holder.0.inner.references.load(Ordering::SeqCst) == 1
+        if let Some(lazy_holder) = entity.get::<LazySignalHolder>() {
+            if lazy_holder.0.inner.references.load(Ordering::SeqCst) == 1 {
+                entity.despawn();
+            }
         } else {
-            // This is a dynamically created signal without an external holder.
-            // It can be despawned now that its graph registrations are gone.
-            true
-        };
-
-        if should_despawn {
+            // This is a dynamically created signal without a holder, it can be despawned once
+            // its registrations are gone.
             entity.despawn();
         }
     }
 
-    // Stage 4: Recurse on parents. This happens _after_ the current node has
+    // Stage 3: Notify parents and recurse. This happens _after_ the current node has
     // been processed and potentially despawned.
     if let Some(upstreams) = upstreams {
         for &upstream_system in upstreams.iter() {
             // Notify the parent to remove this signal from its downstream list.
             if let Ok(mut upstream_entity) = world.get_entity_mut(*upstream_system)
-                && let Some(mut downstream) = upstream_entity.get_mut::<Downstream>() {
-                    downstream.0.remove(&signal);
-                    if downstream.0.is_empty() {
-                        upstream_entity.remove::<Downstream>();
-                    }
+                && let Some(mut downstream) = upstream_entity.get_mut::<Downstream>()
+            {
+                downstream.0.remove(&signal);
+                if downstream.0.is_empty() {
+                    upstream_entity.remove::<Downstream>();
                 }
+            }
 
             // Now, recurse on the parent.
             cleanup_recursive(world, upstream_system);

src/graph.rs

@@ -4,7 +4,7 @@
     feature = "document-features",
     doc = document_features::document_features!()
 )]
-#![no_std]
+#![cfg_attr(not(test), no_std)]
 
 extern crate alloc;
 

src/lib.rs

@@ -58,13 +58,13 @@ impl<U: 'static> Signal for Box<dyn Signal<Item = U> + Send + Sync> {
 ///
 /// Relevant in contexts where some function may require a [`Clone`] [`Signal`], but the concrete
 /// type can't be known at compile-time.
-pub trait SignalClone: Signal + DynClone {}
+pub trait SignalDynClone: Signal + DynClone {}
 
-clone_trait_object!(< T > SignalClone < Item = T >);
+clone_trait_object!(<T> SignalDynClone <Item = T>);
 
-impl<T: Signal + Clone + 'static> SignalClone for T {}
+impl<T: Signal + Clone + 'static> SignalDynClone for T {}
 
-impl<O: 'static> Signal for Box<dyn SignalClone<Item = O> + Send + Sync> {
+impl<O: 'static> Signal for Box<dyn SignalDynClone<Item = O> + Send + Sync> {
     type Item = O;
 
     fn register_boxed_signal(self: Box<Self>, world: &mut World) -> SignalHandle {
@@ -1947,7 +1947,7 @@ pub trait SignalExt: Signal {
     ///     SignalBuilder::from_system(|_: In<()>| 1).dedupe().boxed_clone() // this is a `Dedupe<Source<i32>>`
     /// }; // without the `.boxed_clone()`, the compiler would not allow this
     /// ```
-    fn boxed_clone(self) -> Box<dyn SignalClone<Item = Self::Item>>
+    fn boxed_clone(self) -> Box<dyn SignalDynClone<Item = Self::Item>>
     where
         Self: Sized + Clone,
     {

src/signal.rs

@@ -948,7 +948,7 @@ impl<K, V> MutableBTreeMap<K, V> {
                 clone!(
                     (self_entity) move | In(upstream_diffs): In<Vec<MapDiff<K, V>>>,
                     world: & mut World,
-                    mut has_run: Local < bool >| {
+                    mut has_run: Local <bool>| {
                         if !*has_run {
                             // First run: This is triggered manually by the `MapReplayTrigger`.
                             // It processes the initial state queued on its own entity and ignores upstream.

src/signal_map.rs

@@ -157,13 +157,13 @@ impl<O: 'static> SignalVec for Box<dyn SignalVec<Item = O> + Send + Sync> {
 /// Relevant in contexts where some function may require a [`Clone`] [`SignalVec`], but the concrete
 /// type can't be known at compile-time, e.g. in a
 /// [`.switch_signal_vec`](SignalExt::switch_signal_vec).
-pub trait SignalVecClone: SignalVec + DynClone {}
+pub trait SignalVecDynClone: SignalVec + DynClone {}
 
-clone_trait_object!(< T > SignalVecClone < Item = T >);
+clone_trait_object!(<T> SignalVecDynClone <Item = T>);
 
-impl<T: SignalVec + Clone + 'static> SignalVecClone for T {}
+impl<T: SignalVec + Clone + 'static> SignalVecDynClone for T {}
 
-impl<O: 'static> SignalVec for Box<dyn SignalVecClone<Item = O> + Send + Sync> {
+impl<O: 'static> SignalVec for Box<dyn SignalVecDynClone<Item = O> + Send + Sync> {
     type Item = O;
 
     fn register_boxed_signal_vec(self: Box<Self>, world: &mut World) -> SignalHandle {
@@ -3480,7 +3480,7 @@ pub trait SignalVecExt: SignalVec {
     ///     } // without the `.boxed_clone()`, the compiler would not allow this
     /// });
     /// ```
-    fn boxed_clone(self) -> Box<dyn SignalVecClone<Item = Self::Item> + Send + Sync>
+    fn boxed_clone(self) -> Box<dyn SignalVecDynClone<Item = Self::Item> + Send + Sync>
     where
         Self: Sized + Clone,
     {
@@ -3659,12 +3659,22 @@ impl<T> Clone for MutableVec<T> {
 
 impl<T> Drop for MutableVec<T> {
     fn drop(&mut self) {
+        bevy_log::info!("cur: {}", self.references.load(core::sync::atomic::Ordering::SeqCst));
         if self.references.fetch_sub(1, core::sync::atomic::Ordering::SeqCst) == 1 {
             STALE_MUTABLE_VECS.lock().unwrap().push(self.entity);
         }
     }
 }
 
+#[derive(Component)]
+struct MutableVecHandle<T>(MutableVec<T>);
+
+impl<T> Clone for MutableVecHandle<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
 impl<T> MutableVec<T> {
     /// Provides read-only access to the underlying [`Vec`] via either a `&World` or a
     /// `&Query<MutableVecData<T>>`.
@@ -3721,7 +3731,17 @@ impl<T> MutableVec<T> {
             } else {
                 vec![]
             };
-            world.entity_mut(*replay_signal).insert((QueuedVecDiffs(initial_diffs), VecReplayTrigger(trigger)));
+
+            let mut replay_entity = world.entity_mut(*replay_signal);
+            replay_entity.insert((QueuedVecDiffs(initial_diffs), VecReplayTrigger(trigger)));
+
+            // --- FIX STARTS HERE ---
+            // By inserting a cloned handle onto the signal's entity, we tie the lifetime
+            // of the MutableVecData to the lifetime of the signal itself. When this
+            // signal is cleaned up and its entity is despawned, this component will be
+            // dropped, decrementing the reference count and allowing for proper cleanup.
+            replay_entity.insert(MutableVecHandle(self_.clone()));
+            // --- FIX ENDS HERE ---
 
             pipe_signal(world, broadcaster_system, replay_signal);
             replay_signal
@@ -3927,6 +3947,7 @@ mod tests {
     use crate::JonmoPlugin;
     use bevy::prelude::*;
     use bevy_platform::sync::RwLock;
+    use test_log;
 
     #[derive(Resource, Default, Debug)]
     struct SignalVecOutput<T: Clone + fmt::Debug>(Vec<VecDiff<T>>);
@@ -4978,7 +4999,7 @@ mod tests {
         handle.cleanup(app.world_mut());
     }
 
-    #[test]
+    #[test_log::test]
     fn test_filter_map() {
         // A comprehensive test for `SignalVecExt::filter_map`, covering all `VecDiff`
         // types and the three status-change scenarios for `UpdateAt`.
@@ -5019,6 +5040,7 @@ mod tests {
         // --- 3. Test `Push` ---
         // Push a value that passes the filter_map ("30").
         source_vec.write(app.world_mut()).push("30");
+        drop(source_vec)
         // app.update();
         // let diffs = get_and_clear_output::<u32>(app.world_mut());
         // assert_eq!(diffs.len(), 1);