From 8117a672ca4275f82a00badec036920cf9a54c01 Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Thu, 25 Dec 2025 20:14:13 -0800
Subject: [PATCH 01/15] more

---
 src/builder.rs    |  96 ++++++-
 src/lib.rs        |   4 +-
 src/signal.rs     | 665 +++++++++++++++++++++++++++++++++++++++++++---
 src/signal_map.rs | 140 ++++++++--
 src/signal_vec.rs | 462 +++++++++++++++++++++++++++-----
 src/utils.rs      |   7 +-
 6 files changed, 1239 insertions(+), 135 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 81db7c6..601cb3c 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -2,6 +2,7 @@
 use super::{
     graph::{SignalHandle, SignalHandles},
     signal::{Signal, SignalBuilder, SignalExt},
+    signal_map::{SignalMap, SignalMapExt},
     signal_vec::{SignalVec, SignalVecExt, VecDiff},
     utils::{LazyEntity, SSs, ancestor_map},
 };
@@ -17,6 +18,78 @@ use bevy_platform::{
     sync::{Arc, Mutex},
 };
 
+/// A type-erased signal that can be registered with a [`World`] at spawn time.
+/// 
+/// This trait enables [`JonmoBuilder::hold_signals`] to accept signals that haven't
+/// been registered yet, deferring their registration until the entity is spawned.
+/// 
+/// Use the [`.hold()`](SignalHoldExt::hold) extension method to convert a [`Signal`],
+/// [`SignalVec`], or [`SignalMap`] into a `Box<dyn Holdable>`.
+pub trait Holdable: Send + Sync + 'static {
+    /// Register this signal with the world and return its handle.
+    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle;
+}
+
+// Signal wrapper
+struct HoldableSignal<S>(S);
+
+impl<S: Signal + SSs> Holdable for HoldableSignal<S> {
+    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.0.register(world)
+    }
+}
+
+/// Extension trait for converting a [`Signal`] into a [`Holdable`].
+pub trait SignalHoldExt: Signal + Sized + SSs {
+    /// Convert this signal into a type-erased [`Holdable`] for use with
+    /// [`JonmoBuilder::hold_signals`].
+    fn hold(self) -> Box<dyn Holdable> {
+        Box::new(HoldableSignal(self))
+    }
+}
+
+impl<S: Signal + Sized + SSs> SignalHoldExt for S {}
+
+// SignalVec wrapper
+struct HoldableSignalVec<S>(S);
+
+impl<S: SignalVec + SSs> Holdable for HoldableSignalVec<S> {
+    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.0.register(world)
+    }
+}
+
+/// Extension trait for converting a [`SignalVec`] into a [`Holdable`].
+pub trait SignalVecHoldExt: SignalVec + Sized + SSs {
+    /// Convert this signal vec into a type-erased [`Holdable`] for use with
+    /// [`JonmoBuilder::hold_signals`].
+    fn hold(self) -> Box<dyn Holdable> {
+        Box::new(HoldableSignalVec(self))
+    }
+}
+
+impl<S: SignalVec + Sized + SSs> SignalVecHoldExt for S {}
+
+// SignalMap wrapper
+struct HoldableSignalMap<S>(S);
+
+impl<S: SignalMap + SSs> Holdable for HoldableSignalMap<S> {
+    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.0.register(world)
+    }
+}
+
+/// Extension trait for converting a [`SignalMap`] into a [`Holdable`].
+pub trait SignalMapHoldExt: SignalMap + Sized + SSs {
+    /// Convert this signal map into a type-erased [`Holdable`] for use with
+    /// [`JonmoBuilder::hold_signals`].
+    fn hold(self) -> Box<dyn Holdable> {
+        Box::new(HoldableSignalMap(self))
+    }
+}
+
+impl<S: SignalMap + Sized + SSs> SignalMapHoldExt for S {}
+
 fn on_despawn_hook(mut world: DeferredWorld, ctx: HookContext) {
     let entity = ctx.entity;
     let fs = world
@@ -100,9 +173,25 @@ impl JonmoBuilder {
         })
     }
 
-    /// Attach registered [`SignalHandle`]s to this entity for automatic cleanup on despawn.
-    pub fn hold_signals(self, handles: impl IntoIterator<Item = SignalHandle> + SSs) -> Self {
-        self.on_spawn(move |world, entity| add_handles(world, entity, handles))
+    /// Attach [`Holdable`] signals to this entity for automatic cleanup on despawn.
+    /// 
+    /// Use [`.hold()`](SignalHoldExt::hold) to convert a [`Signal`], [`SignalVec`], or
+    /// [`SignalMap`] into a [`Holdable`].
+    /// 
+    /// # Example
+    /// 
+    /// ```ignore
+    /// let my_signal = SignalBuilder::from_resource::<MyResource>().map_in(|r| r.value).hold();
+    /// let my_signal_vec = my_mutable_vec.signal_vec().hold();
+    /// 
+    /// JonmoBuilder::new()
+    ///     .hold_signals([my_signal, my_signal_vec])
+    /// ```
+    pub fn hold_signals(self, holdables: impl IntoIterator<Item = Box<dyn Holdable>> + SSs) -> Self {
+        self.on_spawn(move |world, entity| {
+            let handles: Vec<_> = holdables.into_iter().map(|h| h.register_holdable(world)).collect();
+            add_handles(world, entity, handles);
+        })
     }
 
     /// Run a function with this builder's [`EntityWorldMut`].
@@ -158,6 +247,7 @@ impl JonmoBuilder {
     }
 
     /// Set the [`LazyEntity`] to this builder's [`Entity`].
+    #[track_caller]
     pub fn lazy_entity(self, entity: LazyEntity) -> Self {
         self.on_spawn(move |_, e| entity.set(e))
     }
diff --git a/src/lib.rs b/src/lib.rs
index 39b9feb..603ca90 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -115,7 +115,9 @@ impl Plugin for JonmoPlugin {
 /// `use jonmo::prelude::*;` imports everything one needs to use start using [jonmo](crate).
 pub mod prelude {
     #[cfg(feature = "builder")]
-    pub use crate::builder::JonmoBuilder;
+    pub use crate::builder::{
+        Holdable, JonmoBuilder, SignalHoldExt, SignalMapHoldExt, SignalVecHoldExt,
+    };
     pub use crate::{
         JonmoPlugin,
         graph::SignalHandles,
diff --git a/src/signal.rs b/src/signal.rs
index 1d996ef..672b5ed 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -75,12 +75,20 @@ impl<O: 'static> Signal for Box<dyn SignalDynClone<Item = O> + Send + Sync> {
 
 /// Signal graph node which takes an input of [`In<()>`] and has no upstreams. See [`SignalBuilder`]
 /// methods for examples.
-#[derive(Clone)]
 pub struct Source<O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> O>,
 }
 
+impl<O> Clone for Source<O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<O> Signal for Source<O>
 where
     O: 'static,
@@ -93,13 +101,25 @@ where
 }
 
 /// Signal graph node which applies a [`System`] to its upstream, see [`.map`](SignalExt::map).
-#[derive(Clone)]
 pub struct Map<Upstream, O> {
     upstream: Upstream,
     signal: LazySignal,
     _marker: PhantomData<fn() -> O>,
 }
 
+impl<Upstream, O> Clone for Map<Upstream, O>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            upstream: self.upstream.clone(),
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for Map<Upstream, O>
 where
     Upstream: Signal,
@@ -117,11 +137,21 @@ where
 
 /// Signal graph node which maps its upstream [`Entity`] to a corresponding [`Component`], see
 /// [.component](SignalExt::component).
-#[derive(Clone)]
 pub struct MapComponent<Upstream, C> {
     signal: Map<Upstream, C>,
 }
 
+impl<Upstream, C> Clone for MapComponent<Upstream, C>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream, C> Signal for MapComponent<Upstream, C>
 where
     Upstream: Signal<Item = Entity>,
@@ -136,11 +166,21 @@ where
 
 /// Signal graph node which maps its upstream [`Entity`] to a corresponding [`Option<Component>`],
 /// see [.component_option](SignalExt::component_option).
-#[derive(Clone)]
 pub struct ComponentOption<Upstream, C> {
     signal: Map<Upstream, Option<C>>,
 }
 
+impl<Upstream, C> Clone for ComponentOption<Upstream, C>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream, C> Signal for ComponentOption<Upstream, C>
 where
     Upstream: Signal<Item = Entity>,
@@ -155,11 +195,21 @@ where
 
 /// Signal graph node which maps its upstream [`Entity`] to its [`Changed`] `C` [`Component`],
 /// see [.component_changed](SignalExt::component_changed).
-#[derive(Clone)]
 pub struct ComponentChanged<Upstream, C> {
     signal: Map<Upstream, C>,
 }
 
+impl<Upstream, C> Clone for ComponentChanged<Upstream, C>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream, C> Signal for ComponentChanged<Upstream, C>
 where
     Upstream: Signal<Item = Entity>,
@@ -174,12 +224,23 @@ where
 
 /// Signal graph node with maps its upstream [`Entity`] to whether it has some [`Component`], see
 /// [`.has_component`](SignalExt::has_component).
-#[derive(Clone)]
 pub struct HasComponent<Upstream, C> {
     signal: Map<Upstream, bool>,
     _marker: PhantomData<fn() -> C>,
 }
 
+impl<Upstream, C> Clone for HasComponent<Upstream, C>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, C> Signal for HasComponent<Upstream, C>
 where
     Upstream: Signal<Item = Entity>,
@@ -194,7 +255,6 @@ where
 
 /// Signal graph node which does not forward upstream duplicates, see
 /// [`.dedupe`](SignalExt::dedupe).
-#[derive(Clone)]
 pub struct Dedupe<Upstream>
 where
     Upstream: Signal,
@@ -202,6 +262,17 @@ where
     signal: Map<Upstream, Upstream::Item>,
 }
 
+impl<Upstream> Clone for Dedupe<Upstream>
+where
+    Upstream: Signal + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for Dedupe<Upstream>
 where
     Upstream: Signal,
@@ -215,12 +286,22 @@ where
 
 /// Signal graph node that terminates forever after forwarding a single upstream value, see
 /// [`.first`](SignalExt::first).
-#[derive(Clone)]
 pub struct First<Upstream>
 where
     Upstream: Signal,
 {
-    signal: Map<Upstream, Upstream::Item>,
+    signal: Take<Upstream>,
+}
+
+impl<Upstream> Clone for First<Upstream>
+where
+    Upstream: Signal + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
 }
 
 impl<Upstream> Signal for First<Upstream>
@@ -234,8 +315,38 @@ where
     }
 }
 
+/// Signal graph node that terminates forever after forwarding `count` upstream values, see
+/// [`.take`](SignalExt::take).
+pub struct Take<Upstream>
+where
+    Upstream: Signal,
+{
+    signal: Map<Upstream, Upstream::Item>,
+}
+
+impl<Upstream> Clone for Take<Upstream>
+where
+    Upstream: Signal + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
+impl<Upstream> Signal for Take<Upstream>
+where
+    Upstream: Signal,
+{
+    type Item = Upstream::Item;
+
+    fn register_boxed_signal(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.signal.register(world)
+    }
+}
+
 /// Signal graph node which combines two upstreams, see [`.combine`](SignalExt::combine).
-#[derive(Clone)]
 pub struct Combine<Left, Right>
 where
     Left: Signal,
@@ -248,6 +359,20 @@ where
     signal: LazySignal,
 }
 
+impl<Left, Right> Clone for Combine<Left, Right>
+where
+    Left: Signal + Clone,
+    Right: Signal + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            left_wrapper: self.left_wrapper.clone(),
+            right_wrapper: self.right_wrapper.clone(),
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Left, Right> Signal for Combine<Left, Right>
 where
     Left: Signal,
@@ -267,11 +392,21 @@ where
 
 /// Signal graph node which outputs equality between its upstream and a fixed value, see
 /// [`.eq`](SignalExt::eq).
-#[derive(Clone)]
 pub struct Eq<Upstream> {
     signal: Map<Upstream, bool>,
 }
 
+impl<Upstream> Clone for Eq<Upstream>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for Eq<Upstream>
 where
     Upstream: Signal,
@@ -285,11 +420,21 @@ where
 
 /// Signal graph node which outputs inequality between its upstream and a fixed value, see
 /// [`.neq`](SignalExt::neq).
-#[derive(Clone)]
 pub struct Neq<Upstream> {
     signal: Map<Upstream, bool>,
 }
 
+impl<Upstream> Clone for Neq<Upstream>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for Neq<Upstream>
 where
     Upstream: Signal,
@@ -303,7 +448,6 @@ where
 }
 
 /// Signal graph node which applies [`ops::Not`] to its upstream, see [`.not`](SignalExt::not).
-#[derive(Clone)]
 pub struct Not<Upstream>
 where
     Upstream: Signal,
@@ -313,6 +457,19 @@ where
     signal: Map<Upstream, <Upstream::Item as ops::Not>::Output>,
 }
 
+impl<Upstream> Clone for Not<Upstream>
+where
+    Upstream: Signal + Clone,
+    <Upstream as Signal>::Item: ops::Not,
+    <<Upstream as Signal>::Item as ops::Not>::Output: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for Not<Upstream>
 where
     Upstream: Signal,
@@ -327,12 +484,20 @@ where
 }
 
 /// Signal graph node which selectively terminates propagation, see [`.filter`](SignalExt::filter).
-#[derive(Clone)]
 pub struct Filter<Upstream> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> Upstream>,
 }
 
+impl<Upstream> Clone for Filter<Upstream> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream> Signal for Filter<Upstream>
 where
     Upstream: Signal,
@@ -351,7 +516,6 @@ struct FlattenState<T> {
 
 /// Signal graph node which forwards the upstream output [`Signal`]'s output, see
 /// [`.flatten`](SignalExt::flatten).
-#[derive(Clone)]
 pub struct Flatten<Upstream>
 where
     Upstream: Signal,
@@ -362,6 +526,19 @@ where
     _marker: PhantomData<fn() -> (Upstream, Upstream::Item)>,
 }
 
+impl<Upstream> Clone for Flatten<Upstream>
+where
+    Upstream: Signal,
+    Upstream::Item: Signal,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream> Signal for Flatten<Upstream>
 where
     Upstream: Signal,
@@ -377,7 +554,6 @@ where
 
 /// Signal graph node which maps its upstream to a [`Signal`], forwarding its output, see
 /// [`.switch`](SignalExt::switch).
-#[derive(Clone)]
 pub struct Switch<Upstream, Other>
 where
     Upstream: Signal,
@@ -387,6 +563,19 @@ where
     signal: Flatten<Map<Upstream, Other>>,
 }
 
+impl<Upstream, Other> Clone for Switch<Upstream, Other>
+where
+    Upstream: Signal,
+    Other: Signal,
+    Other::Item: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream, Other> Signal for Switch<Upstream, Other>
 where
     Upstream: Signal,
@@ -402,7 +591,6 @@ where
 
 /// Signal graph node which maps its upstream to a [`SignalVec`], see
 /// [`.switch_signal_vec`](SignalExt::switch_signal_vec).
-#[derive(Clone)]
 pub struct SwitchSignalVec<Upstream, Switched>
 where
     Upstream: Signal,
@@ -412,6 +600,19 @@ where
     _marker: PhantomData<fn() -> (Upstream, Switched)>,
 }
 
+impl<Upstream, Switched> Clone for SwitchSignalVec<Upstream, Switched>
+where
+    Upstream: Signal,
+    Switched: SignalVec,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, Switched> SignalVec for SwitchSignalVec<Upstream, Switched>
 where
     Upstream: Signal,
@@ -427,7 +628,6 @@ where
 
 /// Signal graph node which maps its upstream to a [`SignalMap`], see
 /// [`.switch_signal_map`](SignalExt::switch_signal_map).
-#[derive(Clone)]
 pub struct SwitchSignalMap<Upstream, Switched>
 where
     Upstream: Signal,
@@ -437,6 +637,19 @@ where
     _marker: PhantomData<fn() -> (Upstream, Switched)>,
 }
 
+impl<Upstream, Switched> Clone for SwitchSignalMap<Upstream, Switched>
+where
+    Upstream: Signal,
+    Switched: SignalMap,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, Switched> SignalMap for SwitchSignalMap<Upstream, Switched>
 where
     Upstream: Signal,
@@ -456,7 +669,6 @@ cfg_if::cfg_if! {
     if #[cfg(feature = "time")] {
         /// Signal graph node which delays the propagation of subsequent upstream outputs, see
         /// [`.throttle`](SignalExt::throttle).
-        #[derive(Clone)]
         pub struct Throttle<Upstream>
         where
             Upstream: Signal,
@@ -464,6 +676,17 @@ cfg_if::cfg_if! {
             signal: Map<Upstream, Upstream::Item>,
         }
 
+        impl<Upstream> Clone for Throttle<Upstream>
+        where
+            Upstream: Signal + Clone,
+        {
+            fn clone(&self) -> Self {
+                Self {
+                    signal: self.signal.clone(),
+                }
+            }
+        }
+
         impl<Upstream> Signal for Throttle<Upstream>
         where
             Upstream: Signal,
@@ -479,12 +702,20 @@ cfg_if::cfg_if! {
 
 /// Signal graph node whose [`System`] depends on its upstream [`bool`] value, see
 /// [`.map_bool`](SignalExt::map_bool).
-#[derive(Clone)]
 pub struct MapBool<Upstream, O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for MapBool<Upstream, O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for MapBool<Upstream, O>
 where
     Upstream: Signal<Item = bool>,
@@ -499,12 +730,20 @@ where
 
 /// Signal graph node whose system only runs when its upstream outputs [`true`], see
 /// [`.map_true`](SignalExt::map_true).
-#[derive(Clone)]
 pub struct MapTrue<Upstream, O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for MapTrue<Upstream, O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for MapTrue<Upstream, O>
 where
     Upstream: Signal<Item = bool>,
@@ -519,12 +758,20 @@ where
 
 /// Signal graph node whose system only runs when its upstream outputs [`false`], see
 /// [`.map_false`](SignalExt::map_false).
-#[derive(Clone)]
 pub struct MapFalse<Upstream, O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for MapFalse<Upstream, O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for MapFalse<Upstream, O>
 where
     Upstream: Signal<Item = bool>,
@@ -539,12 +786,20 @@ where
 
 /// Signal graph node whose [`System`] depends on its upstream [`Option`] value, see
 /// [`.map_option`](SignalExt::map_option).
-#[derive(Clone)]
 pub struct MapOption<Upstream, O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for MapOption<Upstream, O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for MapOption<Upstream, O>
 where
     Upstream: Signal,
@@ -559,12 +814,20 @@ where
 
 /// Signal graph node whose system only runs when its upstream outputs [`Some`], see
 /// [`.map_some`](SignalExt::map_some).
-#[derive(Clone)]
 pub struct MapSome<Upstream, O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for MapSome<Upstream, O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for MapSome<Upstream, O>
 where
     Upstream: Signal,
@@ -579,12 +842,20 @@ where
 
 /// Signal graph node whose system only runs when its upstream outputs [`None`], see
 /// [`.map_none`](SignalExt::map_none).
-#[derive(Clone)]
 pub struct MapNone<Upstream, O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for MapNone<Upstream, O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for MapNone<Upstream, O>
 where
     Upstream: Signal,
@@ -599,7 +870,6 @@ where
 
 /// Signal graph node which maps its upstream [`Vec`] to a [`SignalVec`], see
 /// [`.to_signal_vec`](SignalExt::to_signal_vec).
-#[derive(Clone)]
 pub struct ToSignalVec<Upstream>
 where
     Upstream: Signal,
@@ -608,6 +878,18 @@ where
     _marker: PhantomData<fn() -> Upstream>,
 }
 
+impl<Upstream> Clone for ToSignalVec<Upstream>
+where
+    Upstream: Signal,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, T> SignalVec for ToSignalVec<Upstream>
 where
     Upstream: Signal<Item = Vec<T>>,
@@ -623,7 +905,6 @@ where
 cfg_if::cfg_if! {
     if #[cfg(feature = "tracing")] {
         /// Signal graph node that debug logs its upstream's output, see [`.debug`](SignalExt::debug).
-        #[derive(Clone)]
         pub struct Debug<Upstream>
         where
             Upstream: Signal,
@@ -631,6 +912,17 @@ cfg_if::cfg_if! {
             signal: Map<Upstream, Upstream::Item>,
         }
 
+        impl<Upstream> Clone for Debug<Upstream>
+        where
+            Upstream: Signal + Clone,
+        {
+            fn clone(&self) -> Self {
+                Self {
+                    signal: self.signal.clone(),
+                }
+            }
+        }
+
         impl<Upstream> Signal for Debug<Upstream>
         where
             Upstream: Signal,
@@ -822,7 +1114,6 @@ where
 /// although note that all [`Signal`]s are boxed internally regardless.
 ///
 /// Inspired by <https://github.com/rayon-rs/either>.
-#[derive(Clone)]
 #[allow(missing_docs)]
 pub enum SignalEither<L, R>
 where
@@ -833,6 +1124,19 @@ where
     Right(R),
 }
 
+impl<L, R> Clone for SignalEither<L, R>
+where
+    L: Signal + Clone,
+    R: Signal + Clone,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Self::Left(left) => Self::Left(left.clone()),
+            Self::Right(right) => Self::Right(right.clone()),
+        }
+    }
+}
+
 impl<T, L: Signal<Item = T>, R: Signal<Item = T>> Signal for SignalEither<L, R>
 where
     L: Signal<Item = T>,
@@ -1178,9 +1482,12 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// Outputs this [`Signal`]'s first value and then terminates for all subsequent frames.
+    /// Outputs up to the first `count` values from this [`Signal`], and then terminates for all
+    /// subsequent frames.
     ///
-    /// After the first value is emitted, this signal will stop propagating any further values.
+    /// After `count` values are emitted, this signal will stop propagating any further values.
+    ///
+    /// If `count` is `0`, this will never propagate any values.
     ///
     /// # Example
     ///
@@ -1191,28 +1498,54 @@ pub trait SignalExt: Signal {
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
     ///         *state += 1;
-    ///         *state / 2
+    ///         *state
     ///     }
     /// })
-    /// .first(); // outputs `0` then terminates forever
+    /// .take(2); // outputs `1`, `2`, then terminates forever
     /// ```
-    fn first(self) -> First<Self>
+    fn take(self, count: usize) -> Take<Self>
     where
         Self: Sized,
         Self::Item: Clone + 'static,
     {
-        First {
-            signal: self.map(|In(item): In<Self::Item>, mut first: Local<bool>| {
-                if *first {
+        Take {
+            signal: self.map(move |In(item): In<Self::Item>, mut emitted: Local<usize>| {
+                if *emitted >= count {
                     None
                 } else {
-                    *first = true;
+                    *emitted += 1;
                     Some(item)
                 }
             }),
         }
     }
 
+    /// Outputs this [`Signal`]'s first value and then terminates for all subsequent frames.
+    ///
+    /// After the first value is emitted, this signal will stop propagating any further values.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// SignalBuilder::from_system({
+    ///     move |_: In<()>, mut state: Local<usize>| {
+    ///         *state += 1;
+    ///         *state / 2
+    ///     }
+    /// })
+    /// .first(); // outputs `0` then terminates forever
+    /// ```
+    fn first(self) -> First<Self>
+    where
+        Self: Sized,
+        Self::Item: Clone + 'static,
+    {
+        First { signal: self.take(1) }
+    }
+
     /// Output this [`Signal`]'s equality with a fixed value.
     ///
     /// # Example
@@ -2873,7 +3206,7 @@ mod tests {
         graph::{LazySignalHolder, SignalRegistrationCount},
         prelude::{IntoSignalVecEither, SignalVecExt, clone},
         signal::{SignalBuilder, SignalExt, Upstream},
-        signal_vec::{MutableVecBuilder, VecDiff},
+        signal_vec::{MutableVec, MutableVecBuilder, VecDiff},
         utils::{LazyEntity, SSs},
     };
     use core::{convert::identity, fmt};
@@ -3314,6 +3647,36 @@ mod tests {
         signal.cleanup(app.world_mut());
     }
 
+    #[test]
+    fn test_take() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<i32>>();
+        let counter = Arc::new(Mutex::new(0));
+        let values = Arc::new(Mutex::new(vec![10, 20, 30]));
+        let signal = SignalBuilder::from_system(clone!((values) move |_: In<()>| {
+            let mut values_lock = values.lock().unwrap();
+            if values_lock.is_empty() {
+                None
+            } else {
+                Some(values_lock.remove(0))
+            }
+        }))
+        .take(2)
+        .map(clone!((counter) move |In(val): In<i32>| {
+            *counter.lock().unwrap() += 1;
+            val
+        }))
+        .map(capture_output)
+        .register(app.world_mut());
+        app.update();
+        app.update();
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(20));
+        assert_eq!(*counter.lock().unwrap(), 2);
+        assert_eq!(values.lock().unwrap().len(), 0);
+        signal.cleanup(app.world_mut());
+    }
+
     #[test]
     fn test_combine() {
         let mut app = create_test_app();
@@ -3604,6 +3967,110 @@ mod tests {
         crate::signal_vec::tests::cleanup(true);
     }
 
+    #[test]
+    fn test_switch_signal_vec_initially_empty() {
+        {
+            // --- Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<i32>>();
+
+            // Start with an EMPTY list - this tests the `was_initially_empty` code path
+            let list_a: MutableVec<i32> = app.world_mut().into();
+            let list_b = MutableVecBuilder::from([100, 200, 300]).spawn(app.world_mut());
+            let signal_a = list_a.signal_vec().map_in(identity);
+            let signal_b = list_b.signal_vec();
+
+            // A resource to control which list is active.
+            #[derive(Resource, Clone, Copy, PartialEq, Debug)]
+            enum ListSelector {
+                A,
+                B,
+            }
+
+            app.insert_resource(ListSelector::A);
+
+            // The control signal reads the resource.
+            let control_signal =
+                SignalBuilder::from_system(|_: In<()>, selector: Res<ListSelector>| *selector).dedupe();
+
+            // The signal chain under test.
+            let switched_signal = control_signal.dedupe().switch_signal_vec(
+                clone!((signal_a, signal_b) move |In(selector): In<ListSelector>| match selector {
+                    ListSelector::A => signal_a.clone().left_either(),
+                    ListSelector::B => signal_b.clone().right_either(),
+                }),
+            );
+
+            // Register the final signal to a capture system.
+            let handle = switched_signal.for_each(capture_vec_output).register(app.world_mut());
+
+            // --- Test 1: Initial State with Empty List ---
+            // The first update should select List A which is empty.
+            // With an empty initial list, no Replace diff should be emitted.
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert!(
+                diffs.is_empty(),
+                "Initial update with empty list should produce no diffs, got: {:?}",
+                diffs
+            );
+
+            // --- Test 2: Push to Empty Active List ---
+            // A push to the initially empty List A should be forwarded as a Push.
+            list_a.write(app.world_mut()).push(10);
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push to active list should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Push { value: 10 },
+                "Should forward Push diff from List A."
+            );
+
+            // --- Test 3: Another Push ---
+            list_a.write(app.world_mut()).push(20);
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Second push should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Push { value: 20 },
+                "Should forward second Push diff from List A."
+            );
+
+            // --- Test 4: Switch to List B (non-empty) ---
+            *app.world_mut().resource_mut::<ListSelector>() = ListSelector::B;
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Switching to non-empty list should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec![100, 200, 300]
+                },
+                "Switch should emit a Replace with List B's contents."
+            );
+
+            // --- Test 5: Switch Back to List A (now non-empty) ---
+            // When switching back, List A now has items, so it should emit Replace.
+            *app.world_mut().resource_mut::<ListSelector>() = ListSelector::A;
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Switching back to A should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec![10, 20],
+                },
+                "Switching back should Replace with the current state of List A."
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
+        crate::signal_vec::tests::cleanup(true);
+    }
+
     #[test]
     fn test_switch_signal_map() {
         use crate::signal_map::{IntoSignalMapEither, MapDiff, MutableBTreeMapBuilder, SignalMapExt};
@@ -3744,6 +4211,128 @@ mod tests {
         crate::signal_map::tests::cleanup(true);
     }
 
+    #[test]
+    fn test_switch_signal_map_initially_empty() {
+        use crate::signal_map::{IntoSignalMapEither, MapDiff, MutableBTreeMap, MutableBTreeMapBuilder, SignalMapExt};
+
+        #[derive(Resource, Default, core::fmt::Debug)]
+        struct SignalMapOutput<K, V>(Vec<MapDiff<K, V>>)
+        where
+            K: SSs + Clone + core::fmt::Debug,
+            V: SSs + Clone + core::fmt::Debug;
+
+        fn capture_map_output<K, V>(In(diffs): In<Vec<MapDiff<K, V>>>, mut output: ResMut<SignalMapOutput<K, V>>)
+        where
+            K: SSs + Clone + core::fmt::Debug,
+            V: SSs + Clone + core::fmt::Debug,
+        {
+            output.0.extend(diffs);
+        }
+
+        fn get_and_clear_map_output<K, V>(world: &mut World) -> Vec<MapDiff<K, V>>
+        where
+            K: SSs + Clone + core::fmt::Debug,
+            V: SSs + Clone + core::fmt::Debug,
+        {
+            world
+                .get_resource_mut::<SignalMapOutput<K, V>>()
+                .map(|mut res| core::mem::take(&mut res.0))
+                .unwrap_or_default()
+        }
+
+        {
+            // --- Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalMapOutput<i32, i32>>();
+
+            // Start with an EMPTY map - this tests the `was_initially_empty` code path
+            let map_a: MutableBTreeMap<i32, i32> = app.world_mut().into();
+            let map_b = MutableBTreeMapBuilder::from([(1, 100), (2, 200), (3, 300)]).spawn(app.world_mut());
+            let signal_a = map_a.signal_map().map_value(|In(x): In<i32>| x);
+            let signal_b = map_b.signal_map();
+
+            // A resource to control which map is active.
+            #[derive(Resource, Clone, Copy, PartialEq, Debug)]
+            enum MapSelector {
+                A,
+                B,
+            }
+
+            app.insert_resource(MapSelector::A);
+
+            // The control signal reads the resource.
+            let control_signal = SignalBuilder::from_system(|_: In<()>, selector: Res<MapSelector>| *selector).dedupe();
+
+            // The signal chain under test.
+            let switched_signal = control_signal.dedupe().switch_signal_map(
+                clone!((signal_a, signal_b) move |In(selector): In<MapSelector>| match selector {
+                    MapSelector::A => signal_a.clone().left_either(),
+                    MapSelector::B => signal_b.clone().right_either(),
+                }),
+            );
+
+            // Register the final signal to a capture system.
+            let handle = switched_signal.for_each(capture_map_output).register(app.world_mut());
+
+            // --- Test 1: Initial State with Empty Map ---
+            // The first update should select Map A which is empty.
+            // With an empty initial map, no Replace diff should be emitted.
+            app.update();
+            let diffs = get_and_clear_map_output::<i32, i32>(app.world_mut());
+            assert!(
+                diffs.is_empty(),
+                "Initial update with empty map should produce no diffs, got: {:?}",
+                diffs
+            );
+
+            // --- Test 2: Insert to Empty Active Map ---
+            // An insert to the initially empty Map A should be forwarded as an Insert.
+            map_a.write(app.world_mut()).insert(1, 10);
+            app.update();
+            let diffs = get_and_clear_map_output::<i32, i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Insert to active map should produce one diff.");
+            assert!(
+                matches!(&diffs[0], MapDiff::Insert { key: 1, value: 10 }),
+                "Should forward Insert diff from Map A."
+            );
+
+            // --- Test 3: Another Insert ---
+            map_a.write(app.world_mut()).insert(2, 20);
+            app.update();
+            let diffs = get_and_clear_map_output::<i32, i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Second insert should produce one diff.");
+            assert!(
+                matches!(&diffs[0], MapDiff::Insert { key: 2, value: 20 }),
+                "Should forward second Insert diff from Map A."
+            );
+
+            // --- Test 4: Switch to Map B (non-empty) ---
+            *app.world_mut().resource_mut::<MapSelector>() = MapSelector::B;
+            app.update();
+            let diffs = get_and_clear_map_output::<i32, i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Switching to non-empty map should produce one diff.");
+            assert!(
+                matches!(&diffs[0], MapDiff::Replace { entries } if entries == &vec![(1, 100), (2, 200), (3, 300)]),
+                "Switch should emit a Replace with Map B's contents."
+            );
+
+            // --- Test 5: Switch Back to Map A (now non-empty) ---
+            // When switching back, Map A now has items, so it should emit Replace.
+            *app.world_mut().resource_mut::<MapSelector>() = MapSelector::A;
+            app.update();
+            let diffs = get_and_clear_map_output::<i32, i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Switching back to A should produce one diff.");
+            assert!(
+                matches!(&diffs[0], MapDiff::Replace { entries } if entries == &vec![(1, 10), (2, 20)]),
+                "Switching back should Replace with the current state of Map A."
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
+        crate::signal_map::tests::cleanup(true);
+    }
+
     #[test]
     fn test_throttle() {
         let mut app = App::new();
diff --git a/src/signal_map.rs b/src/signal_map.rs
index 86fa757..2880fab 100644
--- a/src/signal_map.rs
+++ b/src/signal_map.rs
@@ -18,7 +18,7 @@ use bevy_platform::{
     prelude::*,
     sync::{Arc, LazyLock, Mutex},
 };
-use core::{fmt, marker::PhantomData, ops::Deref, sync::atomic::AtomicUsize};
+use core::{fmt, marker::PhantomData, ops::Deref, sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering}};
 use dyn_clone::{DynClone, clone_trait_object};
 
 /// Describes the mutations made to the underlying [`MutableBTreeMap`] that are piped to downstream
@@ -158,13 +158,25 @@ impl<K: 'static, V: 'static> SignalMap for Box<dyn SignalMapDynClone<Key = K, Va
 
 /// Signal graph node which applies a [`System`] directly to the "raw" [`Vec<MapDiff>`]s of its
 /// upstream, see [.for_each](SignalMapExt::for_each).
-#[derive(Clone)]
 pub struct ForEach<Upstream, O> {
     upstream: Upstream,
     signal: LazySignal,
     _marker: PhantomData<fn() -> O>,
 }
 
+impl<Upstream, O> Clone for ForEach<Upstream, O>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            upstream: self.upstream.clone(),
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for ForEach<Upstream, O>
 where
     Upstream: SignalMap,
@@ -182,12 +194,20 @@ where
 
 /// Signal graph node which applies a [`System`] to each [`Value`](SignalMap::Value) of its
 /// upstream, see [`.map_value`](SignalMapExt::map_value).
-#[derive(Clone)]
 pub struct MapValue<Upstream, O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for MapValue<Upstream, O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> SignalMap for MapValue<Upstream, O>
 where
     Upstream: SignalMap,
@@ -204,12 +224,20 @@ where
 /// Signal graph node which applies a [`System`] to each [`Value`](SignalMap::Value) of its
 /// upstream, forwarding the output of each resulting [`Signal`], see
 /// [`.map_value`](SignalMapExt::map_value).
-#[derive(Clone)]
 pub struct MapValueSignal<Upstream, S: Signal> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, S)>,
 }
 
+impl<Upstream, S: Signal> Clone for MapValueSignal<Upstream, S> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, S: Signal> SignalMap for MapValueSignal<Upstream, S>
 where
     Upstream: SignalMap,
@@ -226,7 +254,6 @@ where
 
 /// Signal graph node which maps its upstream [`SignalVec`] to a [`Key`](SignalMap::Key)-lookup
 /// [`Signal`], see [`.key`](SignalMapExt::key).
-#[derive(Clone)]
 pub struct Key<Upstream>
 where
     Upstream: SignalMap,
@@ -234,6 +261,17 @@ where
     inner: ForEach<Upstream, Option<Upstream::Value>>,
 }
 
+impl<Upstream> Clone for Key<Upstream>
+where
+    Upstream: SignalMap + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for Key<Upstream>
 where
     Upstream: SignalMap,
@@ -251,7 +289,6 @@ cfg_if::cfg_if! {
     if #[cfg(feature = "tracing")] {
         /// Signal graph node that debug logs its upstream's "raw" [`Vec<MapDiff>`]s, see
         /// [`.debug`](SignalMapExt::debug).
-        #[derive(Clone)]
         pub struct Debug<Upstream>
         where
             Upstream: SignalMap,
@@ -260,6 +297,17 @@ cfg_if::cfg_if! {
             signal: ForEach<Upstream, Vec<MapDiff<Upstream::Key, Upstream::Value>>>,
         }
 
+        impl<Upstream> Clone for Debug<Upstream>
+        where
+            Upstream: SignalMap + Clone,
+        {
+            fn clone(&self) -> Self {
+                Self {
+                    signal: self.signal.clone(),
+                }
+            }
+        }
+
         impl<Upstream> SignalMap for Debug<Upstream>
         where
             Upstream: SignalMap,
@@ -277,12 +325,20 @@ cfg_if::cfg_if! {
 /// Signal graph node with no upstreams which outputs some [`MutableBTreeMap`]'s sorted
 /// [`Key`](SignalMap::Key)s as a [`SignalVec`], see
 /// [`.signal_vec_keys`](MutableBTreeMap::signal_vec_keys).
-#[derive(Clone)]
 pub struct SignalVecKeys<K> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> K>,
 }
 
+impl<K> Clone for SignalVecKeys<K> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<K> SignalVec for SignalVecKeys<K>
 where
     K: 'static,
@@ -296,12 +352,20 @@ where
 
 /// Signal graph node which maps its upstream [`MutableBTreeMap`] to a [`SignalVec`] of its sorted
 /// `(key, value)`s, see [`.signal_vec_entries`](MutableBTreeMap::signal_vec_entries).
-#[derive(Clone)]
 pub struct SignalVecEntries<K, V> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (K, V)>,
 }
 
+impl<K, V> Clone for SignalVecEntries<K, V> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<K, V> SignalVec for SignalVecEntries<K, V>
 where
     K: 'static,
@@ -318,7 +382,6 @@ where
 /// although note that all [`SignalMap`]s are boxed internally regardless.
 ///
 /// Inspired by <https://github.com/rayon-rs/either>.
-#[derive(Clone)]
 #[allow(missing_docs)]
 pub enum SignalMapEither<L, R>
 where
@@ -329,6 +392,19 @@ where
     Right(R),
 }
 
+impl<L, R> Clone for SignalMapEither<L, R>
+where
+    L: SignalMap + Clone,
+    R: SignalMap + Clone,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Self::Left(left) => Self::Left(left.clone()),
+            Self::Right(right) => Self::Right(right.clone()),
+        }
+    }
+}
+
 impl<K, V, L, R> SignalMap for SignalMapEither<L, R>
 where
     L: SignalMap<Key = K, Value = V>,
@@ -736,7 +812,7 @@ pub trait SignalMapExt: SignalMap {
     fn key(self, key: Self::Key) -> Key<Self>
     where
         Self: Sized,
-        Self::Key: PartialEq + Clone + SSs,
+        Self::Key: PartialEq + SSs,
         Self::Value: Clone + Send + 'static,
     {
         Key {
@@ -780,6 +856,7 @@ pub trait SignalMapExt: SignalMap {
     }
 
     #[cfg(feature = "tracing")]
+    #[track_caller]
     /// Adds debug logging to this [`SignalMap`]'s raw [`MapDiff`] outputs.
     ///
     /// # Example
@@ -894,8 +971,8 @@ impl<T: ?Sized> SignalMapExt for T where T: SignalMap {}
 static STALE_MUTABLE_BTREE_MAPS: LazyLock<Mutex<Vec<Entity>>> = LazyLock::new(Mutex::default);
 
 pub(crate) fn despawn_stale_mutable_btree_maps(world: &mut World) {
-    let mut queue = STALE_MUTABLE_BTREE_MAPS.lock().unwrap();
-    for entity in queue.drain(..) {
+    let queue = STALE_MUTABLE_BTREE_MAPS.lock().unwrap().drain(..).collect::<Vec<_>>();
+    for entity in queue {
         world.despawn(entity);
     }
 }
@@ -1006,7 +1083,7 @@ pub struct MutableBTreeMap<K, V> {
 
 impl<K, V> Clone for MutableBTreeMap<K, V> {
     fn clone(&self) -> Self {
-        self.references.fetch_add(1, core::sync::atomic::Ordering::SeqCst);
+        self.references.fetch_add(1, AtomicOrdering::SeqCst);
         Self {
             entity: self.entity,
             references: self.references.clone(),
@@ -1017,7 +1094,7 @@ impl<K, V> Clone for MutableBTreeMap<K, V> {
 
 impl<K, V> Drop for MutableBTreeMap<K, V> {
     fn drop(&mut self) {
-        if self.references.fetch_sub(1, core::sync::atomic::Ordering::SeqCst) == 1 {
+        if self.references.fetch_sub(1, AtomicOrdering::SeqCst) == 1 {
             STALE_MUTABLE_BTREE_MAPS.lock().unwrap().push(self.entity);
         }
     }
@@ -1025,12 +1102,20 @@ impl<K, V> Drop for MutableBTreeMap<K, V> {
 
 /// Signal graph node with no upstreams which forwards [`Vec<MapDiff<K, V>>`]s flushed from some
 /// source [`MutableBTreeMap<K, V>`], see [`MutableBTreeMap::signal_map`].
-#[derive(Clone)]
 pub struct Source<K, V> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (K, V)>,
 }
 
+impl<K, V> Clone for Source<K, V> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<K, V> SignalMap for Source<K, V>
 where
     K: 'static,
@@ -1124,15 +1209,26 @@ impl<K, V> MutableBTreeMap<K, V> {
             let was_initially_empty = self_.read(&*world).is_empty();
 
             let replay_entity = LazyEntity::new();
-            let replay_system = clone!((self_, replay_entity) move |In(upstream_diffs): In<Vec<MapDiff<K, V>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_btree_map_datas: Query<&MutableBTreeMapData<K, V>>| {
+            let is_first_replay = Arc::new(AtomicBool::new(true));
+            let replay_system = clone!((self_, replay_entity, is_first_replay) move |In(upstream_diffs): In<Vec<MapDiff<K, V>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_btree_map_datas: Query<&MutableBTreeMapData<K, V>>| {
                 if replay_onces.contains(*replay_entity) {
-                    if !was_initially_empty {
-                        let initial_map = self_.read(&mutable_btree_map_datas);
-                        Some(vec![MapDiff::Replace { entries: initial_map.iter().map(|(k, v)| (k.clone(), v.clone())).collect() }])
-                    } else if upstream_diffs.is_empty() {
-                        None
+                    let first_replay = is_first_replay.swap(false, AtomicOrdering::SeqCst);
+                    if first_replay && was_initially_empty {
+                        // Initial replay with empty map - just forward upstream diffs
+                        if upstream_diffs.is_empty() {
+                            None
+                        } else {
+                            Some(upstream_diffs)
+                        }
                     } else {
-                        Some(upstream_diffs)
+                        // Either non-empty initial state, or subsequent replay (e.g., switch_signal_map)
+                        // Always emit Replace with current state
+                        let current_map = self_.read(&mutable_btree_map_datas);
+                        if current_map.is_empty() {
+                            None
+                        } else {
+                            Some(vec![MapDiff::Replace { entries: current_map.iter().map(|(k, v)| (k.clone(), v.clone())).collect() }])
+                        }
                     }
                 } else if upstream_diffs.is_empty() { None } else { Some(upstream_diffs) }
             });
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index 7fadd11..84b7440 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -18,7 +18,7 @@ use bevy_platform::{
     prelude::*,
     sync::{Arc, LazyLock, Mutex},
 };
-use core::{cmp::Ordering, fmt, marker::PhantomData, ops::Deref, sync::atomic::AtomicUsize};
+use core::{cmp::Ordering, fmt, marker::PhantomData, ops::Deref, sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering}};
 use dyn_clone::{DynClone, clone_trait_object};
 
 /// Describes the mutations made to the underlying [`MutableVec`] that are piped to downstream
@@ -173,12 +173,20 @@ impl<T: 'static> SignalVec for Box<dyn SignalVecDynClone<Item = T> + Send + Sync
 
 /// Signal graph node with no upstreams which forwards [`Vec<VecDiff<T>>`]s flushed from some source
 /// [`MutableVec<T>`], see [`MutableVec::signal_vec`].
-#[derive(Clone)]
 pub struct Source<T> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> T>,
 }
 
+impl<T> Clone for Source<T> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<T> SignalVec for Source<T>
 where
     T: 'static,
@@ -192,13 +200,25 @@ where
 
 /// Signal graph node which applies a [`System`] directly to the "raw" [`Vec<VecDiff>`]s of its
 /// upstream, see [`.for_each`](SignalVecExt::for_each).
-#[derive(Clone)]
 pub struct ForEach<Upstream, O> {
     upstream: Upstream,
     signal: LazySignal,
     _marker: PhantomData<fn() -> O>,
 }
 
+impl<Upstream, O> Clone for ForEach<Upstream, O>
+where
+    Upstream: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            upstream: self.upstream.clone(),
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> Signal for ForEach<Upstream, O>
 where
     Upstream: SignalVec,
@@ -216,12 +236,20 @@ where
 
 /// Signal graph node which applies a [`System`] to each [`Item`](SignalVec::Item) of its upstream,
 /// see [`.map`](SignalVecExt::map).
-#[derive(Clone)]
 pub struct Map<Upstream, O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for Map<Upstream, O> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> SignalVec for Map<Upstream, O>
 where
     Upstream: SignalVec,
@@ -240,12 +268,20 @@ struct ItemIndex(usize);
 /// Signal graph node which applies a [`System`] to each [`Item`](SignalVec::Item) of its upstream,
 /// forwarding the output of each resulting [`Signal`], see
 /// [`.map_signal`](SignalVecExt::map_signal).
-#[derive(Clone)]
 pub struct MapSignal<Upstream, S: Signal> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> (Upstream, S)>,
 }
 
+impl<Upstream, S: Signal> Clone for MapSignal<Upstream, S> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, S: Signal> SignalVec for MapSignal<Upstream, S>
 where
     Upstream: SignalVec,
@@ -263,17 +299,17 @@ fn find_index<'a>(indices: impl Iterator<Item = &'a bool>, index: usize) -> usiz
     indices.take(index).filter(|x| **x).count()
 }
 
-fn filter_helper<T, O, O2>(
+/// Helper for `filter` - clones input to pass to system, returns original if predicate passes.
+#[track_caller]
+fn filter_helper<T>(
     world: &mut World,
     diffs: Vec<VecDiff<T::Inner<'static>>>,
-    system: SystemId<T, O>,
-    f: impl Fn(T::Inner<'static>, O) -> Option<O2>,
+    system: SystemId<T, bool>,
     indices: &mut Vec<bool>,
-) -> Option<Vec<VecDiff<O2>>>
+) -> Option<Vec<VecDiff<T::Inner<'static>>>>
 where
     T: SystemInput + 'static,
     T::Inner<'static>: Clone,
-    O: 'static,
 {
     let mut output = vec![];
     for diff in diffs {
@@ -282,23 +318,21 @@ where
                 *indices = Vec::with_capacity(values.len());
                 let mut output = Vec::with_capacity(values.len());
                 for input in values {
-                    let value = world
+                    let include = world
                         .run_system_with(system, input.clone())
-                        .ok()
-                        .and_then(|output| f(input, output));
-                    indices.push(value.is_some());
-                    if let Some(value) = value {
-                        output.push(value);
+                        .unwrap_or(false);
+                    indices.push(include);
+                    if include {
+                        output.push(input);
                     }
                 }
                 Some(VecDiff::Replace { values: output })
             }
             VecDiff::InsertAt { index, value } => {
-                if let Some(value) = world
+                let include = world
                     .run_system_with(system, value.clone())
-                    .ok()
-                    .and_then(|output| f(value, output))
-                {
+                    .unwrap_or(false);
+                if include {
                     indices.insert(index, true);
                     Some(VecDiff::InsertAt {
                         index: find_index(indices.iter(), index),
@@ -310,11 +344,10 @@ where
                 }
             }
             VecDiff::UpdateAt { index, value } => {
-                if let Some(value) = world
+                let include = world
                     .run_system_with(system, value.clone())
-                    .ok()
-                    .and_then(|output| f(value, output))
-                {
+                    .unwrap_or(false);
+                if include {
                     if indices[index] {
                         Some(VecDiff::UpdateAt {
                             index: find_index(indices.iter(), index),
@@ -365,11 +398,128 @@ where
                 }
             }
             VecDiff::Push { value } => {
-                if let Some(value) = world
+                let include = world
                     .run_system_with(system, value.clone())
-                    .ok()
-                    .and_then(|output| f(value, output))
-                {
+                    .unwrap_or(false);
+                if include {
+                    indices.push(true);
+                    Some(VecDiff::Push { value })
+                } else {
+                    indices.push(false);
+                    None
+                }
+            }
+            VecDiff::Pop => {
+                if indices.pop().expect("can't pop from empty vec") {
+                    Some(VecDiff::Pop)
+                } else {
+                    None
+                }
+            }
+            VecDiff::Clear => {
+                indices.clear();
+                Some(VecDiff::Clear)
+            }
+        };
+        if let Some(diff) = diff_option {
+            output.push(diff);
+        }
+    }
+    if output.is_empty() { None } else { Some(output) }
+}
+
+/// Helper for `filter_map` - does NOT clone input, system takes ownership and returns mapped value.
+#[track_caller]
+fn filter_map_helper<T, O>(
+    world: &mut World,
+    diffs: Vec<VecDiff<T::Inner<'static>>>,
+    system: SystemId<T, Option<O>>,
+    indices: &mut Vec<bool>,
+) -> Option<Vec<VecDiff<O>>>
+where
+    T: SystemInput + 'static,
+    O: 'static,
+{
+    let mut output = vec![];
+    for diff in diffs {
+        let diff_option = match diff {
+            VecDiff::Replace { values } => {
+                *indices = Vec::with_capacity(values.len());
+                let mut output = Vec::with_capacity(values.len());
+                for input in values {
+                    let mapped = world.run_system_with(system, input).ok().flatten();
+                    indices.push(mapped.is_some());
+                    if let Some(value) = mapped {
+                        output.push(value);
+                    }
+                }
+                Some(VecDiff::Replace { values: output })
+            }
+            VecDiff::InsertAt { index, value } => {
+                if let Some(value) = world.run_system_with(system, value).ok().flatten() {
+                    indices.insert(index, true);
+                    Some(VecDiff::InsertAt {
+                        index: find_index(indices.iter(), index),
+                        value,
+                    })
+                } else {
+                    indices.insert(index, false);
+                    None
+                }
+            }
+            VecDiff::UpdateAt { index, value } => {
+                if let Some(value) = world.run_system_with(system, value).ok().flatten() {
+                    if indices[index] {
+                        Some(VecDiff::UpdateAt {
+                            index: find_index(indices.iter(), index),
+                            value,
+                        })
+                    } else {
+                        indices[index] = true;
+                        Some(VecDiff::InsertAt {
+                            index: find_index(indices.iter(), index),
+                            value,
+                        })
+                    }
+                } else if indices[index] {
+                    indices[index] = false;
+                    Some(VecDiff::RemoveAt {
+                        index: find_index(indices.iter(), index),
+                    })
+                } else {
+                    None
+                }
+            }
+            VecDiff::Move { old_index, new_index } => {
+                // Determine if the item being moved is part of the filtered set.
+                let was_included = indices[old_index];
+
+                // Calculate the filtered old and new indices BEFORE and AFTER mutating `indices`.
+                let filtered_old_index = find_index(indices.iter(), old_index);
+                let temp_val = indices.remove(old_index);
+                indices.insert(new_index, temp_val);
+                let filtered_new_index = find_index(indices.iter(), new_index);
+
+                if was_included {
+                    Some(VecDiff::Move {
+                        old_index: filtered_old_index,
+                        new_index: filtered_new_index,
+                    })
+                } else {
+                    None
+                }
+            }
+            VecDiff::RemoveAt { index } => {
+                if indices.remove(index) {
+                    Some(VecDiff::RemoveAt {
+                        index: find_index(indices.iter(), index),
+                    })
+                } else {
+                    None
+                }
+            }
+            VecDiff::Push { value } => {
+                if let Some(value) = world.run_system_with(system, value).ok().flatten() {
                     indices.push(true);
                     Some(VecDiff::Push { value })
                 } else {
@@ -398,12 +548,20 @@ where
 
 /// Signal graph node which selectively forwards upstream [`Item`](SignalVec::Item)s, see
 /// [`.filter`](SignalVecExt::filter).
-#[derive(Clone)]
 pub struct Filter<Upstream> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> Upstream>,
 }
 
+impl<Upstream> Clone for Filter<Upstream> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream> SignalVec for Filter<Upstream>
 where
     Upstream: SignalVec,
@@ -417,7 +575,6 @@ where
 
 /// Signal graph node which transforms and selectively forwards upstream [`Item`](SignalVec::Item)s,
 /// see [`.filter_map`](SignalVecExt::filter_map).
-#[derive(Clone)]
 pub struct FilterMap<Upstream, O>
 where
     Upstream: SignalVec,
@@ -426,6 +583,18 @@ where
     _marker: PhantomData<fn() -> (Upstream, O)>,
 }
 
+impl<Upstream, O> Clone for FilterMap<Upstream, O>
+where
+    Upstream: SignalVec,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream, O> SignalVec for FilterMap<Upstream, O>
 where
     Upstream: SignalVec,
@@ -543,12 +712,20 @@ fn spawn_filter_signal<T: Clone + SSs>(
 
 /// Signal graph node which selectively forwards upstream [`Item`](SignalVec::Item)s depending on a
 /// [`Signal<Item = bool>`], see [`.filter_signal`](SignalVecExt::filter_signal).
-#[derive(Clone)]
 pub struct FilterSignal<Upstream> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> Upstream>,
 }
 
+impl<Upstream> Clone for FilterSignal<Upstream> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream> SignalVec for FilterSignal<Upstream>
 where
     Upstream: SignalVec,
@@ -569,7 +746,6 @@ struct EnumerateState {
 
 /// Signal graph node which prepends an index signal to each upstream [`Item`](SignalVec::Item), see
 /// [`.enumerate`](SignalVecExt::enumerate).
-#[derive(Clone)]
 pub struct Enumerate<Upstream>
 where
     Upstream: SignalVec,
@@ -579,6 +755,18 @@ where
     _marker: PhantomData<fn() -> Upstream>,
 }
 
+impl<Upstream> Clone for Enumerate<Upstream>
+where
+    Upstream: SignalVec,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream> SignalVec for Enumerate<Upstream>
 where
     Upstream: SignalVec,
@@ -592,7 +780,6 @@ where
 
 /// Signal graph node which collects upstream [`Item`](SignalVec::Item)s into a single [`Vec`], see
 /// [`.to_signal`](SignalVecExt::to_signal).
-#[derive(Clone)]
 pub struct ToSignal<Upstream>
 where
     Upstream: SignalVec,
@@ -600,6 +787,17 @@ where
     signal: ForEach<Upstream, Vec<Upstream::Item>>,
 }
 
+impl<Upstream> Clone for ToSignal<Upstream>
+where
+    Upstream: SignalVec + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for ToSignal<Upstream>
 where
     Upstream: SignalVec,
@@ -613,7 +811,6 @@ where
 
 /// Signal graph node which outputs whether its upstream is populated, see
 /// [`.is_empty`](SignalVecExt::is_empty).
-#[derive(Clone)]
 pub struct IsEmpty<Upstream>
 where
     Upstream: SignalVec,
@@ -622,6 +819,18 @@ where
     signal: super::signal::Map<ToSignal<Upstream>, bool>,
 }
 
+impl<Upstream> Clone for IsEmpty<Upstream>
+where
+    Upstream: SignalVec + Clone,
+    Upstream::Item: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for IsEmpty<Upstream>
 where
     Upstream: SignalVec,
@@ -635,7 +844,6 @@ where
 }
 
 /// Signal graph node which outputs its upstream's length, see [`.len`](SignalVecExt::len).
-#[derive(Clone)]
 pub struct Len<Upstream>
 where
     Upstream: SignalVec,
@@ -644,6 +852,18 @@ where
     signal: super::signal::Map<ToSignal<Upstream>, usize>,
 }
 
+impl<Upstream> Clone for Len<Upstream>
+where
+    Upstream: SignalVec + Clone,
+    Upstream::Item: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for Len<Upstream>
 where
     Upstream: SignalVec,
@@ -657,7 +877,6 @@ where
 }
 
 /// Signal graph node which outputs its upstream's sum, see [`.sum`](SignalVecExt::sum).
-#[derive(Clone)]
 pub struct Sum<Upstream>
 where
     Upstream: SignalVec,
@@ -665,6 +884,17 @@ where
     signal: super::signal::Map<ToSignal<Upstream>, Upstream::Item>,
 }
 
+impl<Upstream> Clone for Sum<Upstream>
+where
+    Upstream: SignalVec + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> Signal for Sum<Upstream>
 where
     Upstream: SignalVec,
@@ -676,14 +906,24 @@ where
     }
 }
 
-#[derive(Clone)]
 enum LrDiff<T> {
     Left(Vec<VecDiff<T>>),
     Right(Vec<VecDiff<T>>),
 }
 
+impl<T> Clone for LrDiff<T>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Self::Left(left) => Self::Left(left.clone()),
+            Self::Right(right) => Self::Right(right.clone()),
+        }
+    }
+}
+
 /// Signal graph node which concatenates its upstreams, see [`.chain`](SignalVecExt::chain).
-#[derive(Clone)]
 pub struct Chain<Left, Right>
 where
     Left: SignalVec,
@@ -694,6 +934,20 @@ where
     signal: LazySignal,
 }
 
+impl<Left, Right> Clone for Chain<Left, Right>
+where
+    Left: SignalVec + Clone,
+    Right: SignalVec<Item = Left::Item> + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            left_wrapper: self.left_wrapper.clone(),
+            right_wrapper: self.right_wrapper.clone(),
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Left, Right> SignalVec for Chain<Left, Right>
 where
     Left: SignalVec,
@@ -713,7 +967,6 @@ where
 
 /// Signal graph node that places a separator between each upstream [`Item`](SignalVec::Item), see
 /// [`.intersperse`](SignalVecExt::intersperse).
-#[derive(Clone)]
 pub struct Intersperse<Upstream>
 where
     Upstream: SignalVec,
@@ -721,6 +974,17 @@ where
     signal: ForEach<Upstream, Vec<VecDiff<Upstream::Item>>>,
 }
 
+impl<Upstream> Clone for Intersperse<Upstream>
+where
+    Upstream: SignalVec + Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
 impl<Upstream> SignalVec for Intersperse<Upstream>
 where
     Upstream: SignalVec,
@@ -758,12 +1022,20 @@ impl<T> Default for IntersperseState<T> {
 
 /// Signal graph node that places a [`System`]-dependent separator between each upstream
 /// [`Item`](SignalVec::Item), see [`.intersperse_with`](SignalVecExt::intersperse_with).
-#[derive(Clone)]
 pub struct IntersperseWith<Upstream> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> Upstream>,
 }
 
+impl<Upstream> Clone for IntersperseWith<Upstream> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream> SignalVec for IntersperseWith<Upstream>
 where
     Upstream: SignalVec,
@@ -777,12 +1049,20 @@ where
 
 /// Signal graph node that sorts each upstream [`Item`](SignalVec::Item) based on a comparison
 /// [`System`], see [`.sort_by`](SignalVecExt::sort_by).
-#[derive(Clone)]
 pub struct SortBy<Upstream> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> Upstream>,
 }
 
+impl<Upstream> Clone for SortBy<Upstream> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream> SignalVec for SortBy<Upstream>
 where
     Upstream: SignalVec,
@@ -796,12 +1076,20 @@ where
 
 /// Signal graph node that sorts each upstream [`Item`](SignalVec::Item) based on a key extraction
 /// [`System`], see [`.sort_by_key`](SignalVecExt::sort_by_key).
-#[derive(Clone)]
 pub struct SortByKey<Upstream> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> Upstream>,
 }
 
+impl<Upstream> Clone for SortByKey<Upstream> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
 impl<Upstream> SignalVec for SortByKey<Upstream>
 where
     Upstream: SignalVec,
@@ -813,7 +1101,7 @@ where
     }
 }
 
-/* #[derive(Clone)]
+/*
 struct FlattenItem<O: SSs + Clone> {
     processor_handle: SignalHandle,
     values: Vec<O>,
@@ -994,7 +1282,6 @@ cfg_if::cfg_if! {
     if #[cfg(feature = "tracing")] {
         /// Signal graph node that debug logs its upstream's "raw" [`Vec<VecDiff>`]s, see
         /// [`.debug`](SignalVecExt::debug).
-        #[derive(Clone)]
         pub struct Debug<Upstream>
         where
             Upstream: SignalVec,
@@ -1002,6 +1289,17 @@ cfg_if::cfg_if! {
             signal: ForEach<Upstream, Vec<VecDiff<Upstream::Item>>>,
         }
 
+        impl<Upstream> Clone for Debug<Upstream>
+        where
+            Upstream: SignalVec + Clone,
+        {
+            fn clone(&self) -> Self {
+                Self {
+                    signal: self.signal.clone(),
+                }
+            }
+        }
+
         impl<Upstream> SignalVec for Debug<Upstream>
         where
             Upstream: SignalVec,
@@ -1019,7 +1317,6 @@ cfg_if::cfg_if! {
 /// although note that all [`SignalVec`]s are boxed internally regardless.
 ///
 /// Inspired by <https://github.com/rayon-rs/either>.
-#[derive(Clone)]
 #[allow(missing_docs)]
 pub enum SignalVecEither<L, R>
 where
@@ -1030,6 +1327,19 @@ where
     Right(R),
 }
 
+impl<L, R> Clone for SignalVecEither<L, R>
+where
+    L: SignalVec + Clone,
+    R: SignalVec + Clone,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Self::Left(left) => Self::Left(left.clone()),
+            Self::Right(right) => Self::Right(right.clone()),
+        }
+    }
+}
+
 impl<T, L: SignalVec<Item = T>, R: SignalVec<Item = T>> SignalVec for SignalVecEither<L, R>
 where
     L: SignalVec<Item = T>,
@@ -1140,6 +1450,7 @@ pub trait SignalVecExt: SignalVec {
     /// [`.for_each`](SignalVecExt::for_each), returns a [`Signal`], not a [`SignalVec`], since the
     /// output type need not be an [`Option<Vec<VecDiff>>`]. If the [`System`] logic is infallible,
     /// wrapping the result in an option is unnecessary.
+    #[track_caller]
     fn for_each<O, IOO, F, M>(self, system: F) -> ForEach<Self, O>
     where
         Self: Sized,
@@ -1310,7 +1621,7 @@ pub trait SignalVecExt: SignalVec {
     fn map_signal<S, F, M>(self, system: F) -> MapSignal<Self, S>
     where
         Self: Sized,
-        Self::Item: Clone + SSs,
+        Self::Item: SSs,
         S: Signal + 'static + Clone,
         S::Item: Clone + Send + Sync,
         F: IntoSystem<In<Self::Item>, S, M> + SSs,
@@ -1593,15 +1904,7 @@ pub trait SignalVecExt: SignalVec {
             let SignalHandle(signal) = self
                 .for_each::<Vec<VecDiff<Self::Item>>, _, _, _>(
                     move |In(diffs): In<Vec<VecDiff<Self::Item>>>, world: &mut World, mut indices: Local<Vec<bool>>| {
-                        filter_helper(
-                            world,
-                            diffs,
-                            system,
-                            |item, include| {
-                                if include { Some(item) } else { None }
-                            },
-                            &mut indices,
-                        )
+                        filter_helper(world, diffs, system, &mut indices)
                     },
                 )
                 .register(world);
@@ -1631,10 +1934,11 @@ pub trait SignalVecExt: SignalVec {
     ///     .signal_vec()
     ///     .filter_map(|In(s): In<&'static str>| s.parse::<u32>().ok()); // outputs `SignalVec -> [1, 5]`
     /// ```
+    #[track_caller]
     fn filter_map<O, F, M>(self, system: F) -> FilterMap<Self, O>
     where
         Self: Sized,
-        Self::Item: Clone + 'static,
+        Self::Item: 'static,
         O: Clone + 'static,
         F: IntoSystem<In<Self::Item>, Option<O>, M> + SSs,
     {
@@ -1643,7 +1947,7 @@ pub trait SignalVecExt: SignalVec {
             let SignalHandle(signal) = self
                 .for_each::<Vec<VecDiff<O>>, _, _, _>(
                     move |In(diffs): In<Vec<VecDiff<Self::Item>>>, world: &mut World, mut indices: Local<Vec<bool>>| {
-                        filter_helper(world, diffs, system, |_, mapped| mapped, &mut indices)
+                        filter_map_helper(world, diffs, system, &mut indices)
                     },
                 )
                 .register(world);
@@ -3490,6 +3794,7 @@ pub trait SignalVecExt: SignalVec {
     } */
 
     #[cfg(feature = "tracing")]
+    #[track_caller]
     /// Adds debug logging to this [`SignalVec`]'s raw [`VecDiff`] outputs.
     ///
     /// # Example
@@ -3747,7 +4052,7 @@ pub struct MutableVec<T> {
 
 impl<T> Clone for MutableVec<T> {
     fn clone(&self) -> Self {
-        self.references.fetch_add(1, core::sync::atomic::Ordering::SeqCst);
+        self.references.fetch_add(1, AtomicOrdering::SeqCst);
         Self {
             entity: self.entity,
             references: self.references.clone(),
@@ -3758,7 +4063,7 @@ impl<T> Clone for MutableVec<T> {
 
 impl<T> Drop for MutableVec<T> {
     fn drop(&mut self) {
-        if self.references.fetch_sub(1, core::sync::atomic::Ordering::SeqCst) == 1 {
+        if self.references.fetch_sub(1, AtomicOrdering::SeqCst) == 1 {
             STALE_MUTABLE_VECS.lock().unwrap().push(self.entity);
         }
     }
@@ -3797,15 +4102,26 @@ impl<T> MutableVec<T> {
             let was_initially_empty = self_.read(&*world).is_empty();
 
             let replay_entity = LazyEntity::new();
-            let replay_system = clone!((self_, replay_entity) move |In(upstream_diffs): In<Vec<VecDiff<T>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_vec_datas: Query<&MutableVecData<T>>| {
+            let is_first_replay = Arc::new(AtomicBool::new(true));
+            let replay_system = clone!((self_, replay_entity, is_first_replay) move |In(upstream_diffs): In<Vec<VecDiff<T>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_vec_datas: Query<&MutableVecData<T>>| {
                 if replay_onces.contains(*replay_entity) {
-                    if !was_initially_empty {
-                        let initial_vec = self_.read(&mutable_vec_datas).to_vec();
-                        Some(vec![VecDiff::Replace { values: initial_vec }])
-                    } else if upstream_diffs.is_empty() {
-                        None
+                    let first_replay = is_first_replay.swap(false, AtomicOrdering::SeqCst);
+                    if first_replay && was_initially_empty {
+                        // Initial replay with empty vec - just forward upstream diffs
+                        if upstream_diffs.is_empty() {
+                            None
+                        } else {
+                            Some(upstream_diffs)
+                        }
                     } else {
-                        Some(upstream_diffs)
+                        // Either non-empty initial state, or subsequent replay (e.g., switch_signal_vec)
+                        // Always emit Replace with current state
+                        let current_vec = self_.read(&mutable_vec_datas).to_vec();
+                        if current_vec.is_empty() {
+                            None
+                        } else {
+                            Some(vec![VecDiff::Replace { values: current_vec }])
+                        }
                     }
                 } else if upstream_diffs.is_empty() { None } else { Some(upstream_diffs) }
             });
@@ -3831,8 +4147,8 @@ impl<T> MutableVec<T> {
 }
 
 pub(crate) fn despawn_stale_mutable_vecs(world: &mut World) {
-    let mut queue = STALE_MUTABLE_VECS.lock().unwrap();
-    for entity in queue.drain(..) {
+    let queue = STALE_MUTABLE_VECS.lock().unwrap().drain(..).collect::<Vec<_>>();
+    for entity in queue {
         world.despawn(entity);
     }
 }
@@ -6568,13 +6884,21 @@ pub(crate) mod tests {
 
     /// A helper enum to represent the items in our final interspersed vector,
     /// allowing us to distinguish between original items and generated separators.
-    #[derive(Clone)]
     enum ItemOrSep {
         Item(u32),
         // The separator variant holds the *unregistered* index signal.
         Sep(crate::signal::Source<Option<usize>>),
     }
 
+    impl Clone for ItemOrSep {
+        fn clone(&self) -> Self {
+            match self {
+                Self::Item(i) => Self::Item(*i),
+                Self::Sep(s) => Self::Sep(s.clone()),
+            }
+        }
+    }
+
     // Manual `Debug` implementation is required because `Source` does not implement it.
     impl fmt::Debug for ItemOrSep {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/src/utils.rs b/src/utils.rs
index dc820ab..86ee50e 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -11,7 +11,7 @@ pub use enclose::enclose as clone;
 #[derive(Default, Clone)]
 pub struct LazyEntity(Arc<OnceLock<Entity>>);
 
-const LAZY_ENTITY_GET_ERROR: &str = "EntityHolder does not contain an Entity";
+const LAZY_ENTITY_GET_ERROR: &str = "LazyEntity does not contain an Entity";
 
 impl LazyEntity {
     #[allow(missing_docs)]
@@ -20,11 +20,13 @@ impl LazyEntity {
     }
 
     /// Set the [`Entity`], panicking if it was already set.
+    #[track_caller]
     pub fn set(&self, entity: Entity) {
-        self.0.set(entity).expect("EntityHolder already contains an Entity");
+        self.0.set(entity).expect("LazyEntity already contains an Entity");
     }
 
     /// Get the [`Entity`], panicking if it was not set.
+    #[track_caller]
     pub fn get(&self) -> Entity {
         self.0.get().copied().expect(LAZY_ENTITY_GET_ERROR)
     }
@@ -33,6 +35,7 @@ impl LazyEntity {
 impl Deref for LazyEntity {
     type Target = Entity;
 
+    #[track_caller]
     fn deref(&self) -> &Self::Target {
         self.0.get().expect(LAZY_ENTITY_GET_ERROR)
     }

From 31f8de10489e2c29ed3e1d1ba74a939a79c32324 Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Thu, 25 Dec 2025 22:12:26 -0800
Subject: [PATCH 02/15] clean

---
 src/builder.rs    | 236 ++++++++++++++++++++++++----------------------
 src/lib.rs        |   4 +-
 src/signal.rs     |   9 +-
 src/signal_map.rs |   7 +-
 src/signal_vec.rs |  33 +++----
 5 files changed, 147 insertions(+), 142 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 601cb3c..9ac0480 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -18,109 +18,6 @@ use bevy_platform::{
     sync::{Arc, Mutex},
 };
 
-/// A type-erased signal that can be registered with a [`World`] at spawn time.
-/// 
-/// This trait enables [`JonmoBuilder::hold_signals`] to accept signals that haven't
-/// been registered yet, deferring their registration until the entity is spawned.
-/// 
-/// Use the [`.hold()`](SignalHoldExt::hold) extension method to convert a [`Signal`],
-/// [`SignalVec`], or [`SignalMap`] into a `Box<dyn Holdable>`.
-pub trait Holdable: Send + Sync + 'static {
-    /// Register this signal with the world and return its handle.
-    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle;
-}
-
-// Signal wrapper
-struct HoldableSignal<S>(S);
-
-impl<S: Signal + SSs> Holdable for HoldableSignal<S> {
-    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
-        self.0.register(world)
-    }
-}
-
-/// Extension trait for converting a [`Signal`] into a [`Holdable`].
-pub trait SignalHoldExt: Signal + Sized + SSs {
-    /// Convert this signal into a type-erased [`Holdable`] for use with
-    /// [`JonmoBuilder::hold_signals`].
-    fn hold(self) -> Box<dyn Holdable> {
-        Box::new(HoldableSignal(self))
-    }
-}
-
-impl<S: Signal + Sized + SSs> SignalHoldExt for S {}
-
-// SignalVec wrapper
-struct HoldableSignalVec<S>(S);
-
-impl<S: SignalVec + SSs> Holdable for HoldableSignalVec<S> {
-    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
-        self.0.register(world)
-    }
-}
-
-/// Extension trait for converting a [`SignalVec`] into a [`Holdable`].
-pub trait SignalVecHoldExt: SignalVec + Sized + SSs {
-    /// Convert this signal vec into a type-erased [`Holdable`] for use with
-    /// [`JonmoBuilder::hold_signals`].
-    fn hold(self) -> Box<dyn Holdable> {
-        Box::new(HoldableSignalVec(self))
-    }
-}
-
-impl<S: SignalVec + Sized + SSs> SignalVecHoldExt for S {}
-
-// SignalMap wrapper
-struct HoldableSignalMap<S>(S);
-
-impl<S: SignalMap + SSs> Holdable for HoldableSignalMap<S> {
-    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
-        self.0.register(world)
-    }
-}
-
-/// Extension trait for converting a [`SignalMap`] into a [`Holdable`].
-pub trait SignalMapHoldExt: SignalMap + Sized + SSs {
-    /// Convert this signal map into a type-erased [`Holdable`] for use with
-    /// [`JonmoBuilder::hold_signals`].
-    fn hold(self) -> Box<dyn Holdable> {
-        Box::new(HoldableSignalMap(self))
-    }
-}
-
-impl<S: SignalMap + Sized + SSs> SignalMapHoldExt for S {}
-
-fn on_despawn_hook(mut world: DeferredWorld, ctx: HookContext) {
-    let entity = ctx.entity;
-    let fs = world
-        .get_mut::<OnDespawnCallbacks>(entity)
-        .unwrap()
-        .0
-        .drain(..)
-        .collect::<Vec<_>>();
-    for f in fs {
-        f(&mut world, entity);
-    }
-}
-
-#[allow(clippy::type_complexity)]
-#[derive(Component)]
-#[component(on_remove = on_despawn_hook)]
-struct OnDespawnCallbacks(Vec<Box<dyn FnOnce(&mut DeferredWorld, Entity) + Send + Sync + 'static>>);
-
-fn add_handles<I>(world: &mut World, entity: Entity, handles: I)
-where
-    I: IntoIterator<Item = SignalHandle>,
-{
-    if let Ok(mut entity) = world.get_entity_mut(entity)
-        && let Some(mut existing_handles) = entity.get_mut::<SignalHandles>()
-    {
-        for handle in handles {
-            existing_handles.add(handle);
-        }
-    }
-}
-
 // TODO: the fluent interface link breaks cargo fmt ??
 /// A thin facade over a Bevy [`Entity`] enabling the ergonomic registration of
 /// reactive components and children using a declarative
@@ -174,18 +71,33 @@ impl JonmoBuilder {
     }
 
     /// Attach [`Holdable`] signals to this entity for automatic cleanup on despawn.
-    /// 
+    ///
     /// Use [`.hold()`](SignalHoldExt::hold) to convert a [`Signal`], [`SignalVec`], or
     /// [`SignalMap`] into a [`Holdable`].
-    /// 
+    ///
     /// # Example
-    /// 
-    /// ```ignore
-    /// let my_signal = SignalBuilder::from_resource::<MyResource>().map_in(|r| r.value).hold();
-    /// let my_signal_vec = my_mutable_vec.signal_vec().hold();
-    /// 
-    /// JonmoBuilder::new()
-    ///     .hold_signals([my_signal, my_signal_vec])
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// #[derive(Resource, Clone)]
+    /// struct MyResource {
+    ///     value: i32,
+    /// }
+    ///
+    /// let my_signal = SignalBuilder::from_resource::<MyResource>()
+    ///     .map_in(|r: MyResource| println!("{}", r.value))
+    ///     .hold();
+    ///
+    /// let mut world = World::new();
+    /// let my_mutable_vec = MutableVecBuilder::from([1, 2, 3]).spawn(&mut world);
+    /// let my_signal_vec = my_mutable_vec
+    ///     .signal_vec()
+    ///     .map_in(|item: i32| println!("{}", item))
+    ///     .hold();
+    ///
+    /// JonmoBuilder::new().hold_signals([my_signal, my_signal_vec]);
     /// ```
     pub fn hold_signals(self, holdables: impl IntoIterator<Item = Box<dyn Holdable>> + SSs) -> Self {
         self.on_spawn(move |world, entity| {
@@ -826,6 +738,106 @@ impl JonmoBuilder {
     }
 }
 
+/// A type-erased signal that can be registered with a [`World`] at spawn time.
+///
+/// This trait enables [`JonmoBuilder::hold_signals`] to accept signals that haven't
+/// been registered yet, deferring their registration until the entity is spawned.
+///
+/// Use the [`.hold()`](SignalHoldExt::hold) extension method to convert a [`Signal`],
+/// [`SignalVec`], or [`SignalMap`] into a `Box<dyn Holdable>`.
+pub trait Holdable: Send + Sync + 'static {
+    /// Register this signal with the world and return its handle.
+    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle;
+}
+
+struct HoldableSignal<S>(S);
+
+impl<S: Signal + SSs> Holdable for HoldableSignal<S> {
+    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.0.register(world)
+    }
+}
+
+/// Extension trait for converting a [`Signal`] into a [`Holdable`].
+pub trait SignalHoldExt: Signal + Sized + SSs {
+    /// Convert this signal into a type-erased [`Holdable`] for use with
+    /// [`JonmoBuilder::hold_signals`].
+    fn hold(self) -> Box<dyn Holdable> {
+        Box::new(HoldableSignal(self))
+    }
+}
+
+impl<S: Signal + Sized + SSs> SignalHoldExt for S {}
+
+struct HoldableSignalVec<S>(S);
+
+impl<S: SignalVec + SSs> Holdable for HoldableSignalVec<S> {
+    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.0.register(world)
+    }
+}
+
+/// Extension trait for converting a [`SignalVec`] into a [`Holdable`].
+pub trait SignalVecHoldExt: SignalVec + Sized + SSs {
+    /// Convert this signal vec into a type-erased [`Holdable`] for use with
+    /// [`JonmoBuilder::hold_signals`].
+    fn hold(self) -> Box<dyn Holdable> {
+        Box::new(HoldableSignalVec(self))
+    }
+}
+
+impl<S: SignalVec + Sized + SSs> SignalVecHoldExt for S {}
+
+struct HoldableSignalMap<S>(S);
+
+impl<S: SignalMap + SSs> Holdable for HoldableSignalMap<S> {
+    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.0.register(world)
+    }
+}
+
+/// Extension trait for converting a [`SignalMap`] into a [`Holdable`].
+pub trait SignalMapHoldExt: SignalMap + Sized + SSs {
+    /// Convert this signal map into a type-erased [`Holdable`] for use with
+    /// [`JonmoBuilder::hold_signals`].
+    fn hold(self) -> Box<dyn Holdable> {
+        Box::new(HoldableSignalMap(self))
+    }
+}
+
+impl<S: SignalMap + Sized + SSs> SignalMapHoldExt for S {}
+
+fn on_despawn_hook(mut world: DeferredWorld, ctx: HookContext) {
+    let entity = ctx.entity;
+    let fs = world
+        .get_mut::<OnDespawnCallbacks>(entity)
+        .unwrap()
+        .0
+        .drain(..)
+        .collect::<Vec<_>>();
+    for f in fs {
+        f(&mut world, entity);
+    }
+}
+
+#[allow(clippy::type_complexity)]
+#[derive(Component)]
+#[component(on_remove = on_despawn_hook)]
+struct OnDespawnCallbacks(Vec<Box<dyn FnOnce(&mut DeferredWorld, Entity) + Send + Sync + 'static>>);
+
+fn add_handles<I>(world: &mut World, entity: Entity, handles: I)
+where
+    I: IntoIterator<Item = SignalHandle>,
+{
+    if let Ok(mut entity) = world.get_entity_mut(entity)
+        && let Some(mut existing_handles) = entity.get_mut::<SignalHandles>()
+    {
+        for handle in handles {
+            existing_handles.add(handle);
+        }
+    }
+}
+
 fn offset(i: usize, child_block_populations: &[usize]) -> usize {
     child_block_populations[..i].iter().sum()
 }
diff --git a/src/lib.rs b/src/lib.rs
index 603ca90..827781e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -115,9 +115,7 @@ impl Plugin for JonmoPlugin {
 /// `use jonmo::prelude::*;` imports everything one needs to use start using [jonmo](crate).
 pub mod prelude {
     #[cfg(feature = "builder")]
-    pub use crate::builder::{
-        Holdable, JonmoBuilder, SignalHoldExt, SignalMapHoldExt, SignalVecHoldExt,
-    };
+    pub use crate::builder::{Holdable, JonmoBuilder, SignalHoldExt, SignalMapHoldExt, SignalVecHoldExt};
     pub use crate::{
         JonmoPlugin,
         graph::SignalHandles,
diff --git a/src/signal.rs b/src/signal.rs
index 672b5ed..2cd26ee 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -2779,20 +2779,19 @@ pub trait SignalExt: Signal {
         }
     }
 
-    // TODO: why won't doctest compile ?
     #[cfg(feature = "tracing")]
     #[track_caller]
     /// Adds debug logging to this [`Signal`]'s ouptut.
     ///
     /// # Example
     ///
-    /// ```ignore
+    /// ```
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
     /// SignalBuilder::from_system(|_: In<()>| 1)
     ///     .debug() // logs `1`
-    ///     .map_in(|x: i32| x * 2);
+    ///     .map_in(|x: i32| x * 2)
     ///     .debug(); // logs `2`
     /// ```
     fn debug(self) -> Debug<Self>
@@ -4059,9 +4058,7 @@ mod tests {
             assert_eq!(diffs.len(), 1, "Switching back to A should produce one diff.");
             assert_eq!(
                 diffs[0],
-                VecDiff::Replace {
-                    values: vec![10, 20],
-                },
+                VecDiff::Replace { values: vec![10, 20] },
                 "Switching back should Replace with the current state of List A."
             );
 
diff --git a/src/signal_map.rs b/src/signal_map.rs
index 2880fab..587f8a3 100644
--- a/src/signal_map.rs
+++ b/src/signal_map.rs
@@ -18,7 +18,12 @@ use bevy_platform::{
     prelude::*,
     sync::{Arc, LazyLock, Mutex},
 };
-use core::{fmt, marker::PhantomData, ops::Deref, sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering}};
+use core::{
+    fmt,
+    marker::PhantomData,
+    ops::Deref,
+    sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering},
+};
 use dyn_clone::{DynClone, clone_trait_object};
 
 /// Describes the mutations made to the underlying [`MutableBTreeMap`] that are piped to downstream
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index 84b7440..096575c 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -18,7 +18,13 @@ use bevy_platform::{
     prelude::*,
     sync::{Arc, LazyLock, Mutex},
 };
-use core::{cmp::Ordering, fmt, marker::PhantomData, ops::Deref, sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering}};
+use core::{
+    cmp::Ordering,
+    fmt,
+    marker::PhantomData,
+    ops::Deref,
+    sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering},
+};
 use dyn_clone::{DynClone, clone_trait_object};
 
 /// Describes the mutations made to the underlying [`MutableVec`] that are piped to downstream
@@ -300,7 +306,6 @@ fn find_index<'a>(indices: impl Iterator<Item = &'a bool>, index: usize) -> usiz
 }
 
 /// Helper for `filter` - clones input to pass to system, returns original if predicate passes.
-#[track_caller]
 fn filter_helper<T>(
     world: &mut World,
     diffs: Vec<VecDiff<T::Inner<'static>>>,
@@ -318,9 +323,7 @@ where
                 *indices = Vec::with_capacity(values.len());
                 let mut output = Vec::with_capacity(values.len());
                 for input in values {
-                    let include = world
-                        .run_system_with(system, input.clone())
-                        .unwrap_or(false);
+                    let include = world.run_system_with(system, input.clone()).unwrap_or(false);
                     indices.push(include);
                     if include {
                         output.push(input);
@@ -329,9 +332,7 @@ where
                 Some(VecDiff::Replace { values: output })
             }
             VecDiff::InsertAt { index, value } => {
-                let include = world
-                    .run_system_with(system, value.clone())
-                    .unwrap_or(false);
+                let include = world.run_system_with(system, value.clone()).unwrap_or(false);
                 if include {
                     indices.insert(index, true);
                     Some(VecDiff::InsertAt {
@@ -344,9 +345,7 @@ where
                 }
             }
             VecDiff::UpdateAt { index, value } => {
-                let include = world
-                    .run_system_with(system, value.clone())
-                    .unwrap_or(false);
+                let include = world.run_system_with(system, value.clone()).unwrap_or(false);
                 if include {
                     if indices[index] {
                         Some(VecDiff::UpdateAt {
@@ -398,9 +397,7 @@ where
                 }
             }
             VecDiff::Push { value } => {
-                let include = world
-                    .run_system_with(system, value.clone())
-                    .unwrap_or(false);
+                let include = world.run_system_with(system, value.clone()).unwrap_or(false);
                 if include {
                     indices.push(true);
                     Some(VecDiff::Push { value })
@@ -429,7 +426,6 @@ where
 }
 
 /// Helper for `filter_map` - does NOT clone input, system takes ownership and returns mapped value.
-#[track_caller]
 fn filter_map_helper<T, O>(
     world: &mut World,
     diffs: Vec<VecDiff<T::Inner<'static>>>,
@@ -1450,7 +1446,6 @@ pub trait SignalVecExt: SignalVec {
     /// [`.for_each`](SignalVecExt::for_each), returns a [`Signal`], not a [`SignalVec`], since the
     /// output type need not be an [`Option<Vec<VecDiff>>`]. If the [`System`] logic is infallible,
     /// wrapping the result in an option is unnecessary.
-    #[track_caller]
     fn for_each<O, IOO, F, M>(self, system: F) -> ForEach<Self, O>
     where
         Self: Sized,
@@ -1934,7 +1929,6 @@ pub trait SignalVecExt: SignalVec {
     ///     .signal_vec()
     ///     .filter_map(|In(s): In<&'static str>| s.parse::<u32>().ok()); // outputs `SignalVec -> [1, 5]`
     /// ```
-    #[track_caller]
     fn filter_map<O, F, M>(self, system: F) -> FilterMap<Self, O>
     where
         Self: Sized,
@@ -2925,7 +2919,6 @@ pub trait SignalVecExt: SignalVec {
     }
 
     // TODO: the example is clearly a copout ...
-    // TODO: why won't doctest compile ?
     /// Place the [`Item`](SignalVec::Item) output by the [`System`] between adjacent items of this
     /// [`SignalVec`]; the [`System`] takes [`In`] a [`Signal<Item = Option<usize>>`] which outputs
     /// the index of the corresponding [`Item`](SignalVec::Item) or [`None`] if it has been removed.
@@ -2934,13 +2927,13 @@ pub trait SignalVecExt: SignalVec {
     ///
     /// # Example
     ///
-    /// ```ignore
+    /// ```
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     /// use jonmo::signal::{Dedupe, Source};
     ///
     /// let mut world = World::new();
-    /// MutableVec::from([1, 2, 3]).spawn(&mut world).signal_vec().intersperse_with(|_: In<Source<Option<usize>>| 0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
+    /// MutableVecBuilder::from([1, 2, 3]).spawn(&mut world).signal_vec().intersperse_with(|_: In<Source<Option<usize>>>| 0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
     /// ```
     fn intersperse_with<F, M>(self, separator_system: F) -> IntersperseWith<Self>
     where

From 2ec12420c492b76d325fbf86eddb22bd7357afba Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Thu, 25 Dec 2025 22:34:55 -0800
Subject: [PATCH 03/15] again

---
 CHANGELOG.md      |  14 +++
 src/builder.rs    | 221 ++++++++++++++++++++++++++++++++++++++++++++++
 src/signal_vec.rs | 164 ++++++++--------------------------
 3 files changed, 272 insertions(+), 127 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7cfc4b9..fcc11d7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,20 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ## unreleased
 
+### changed
+
+- `JonmoBuilder::hold_signals` takes `Box<dyn Holdable>`s instead of `SignalHandles`
+- removed output `Clone` bound from `SignalExt::filter_map`
+
+### added
+- `track_caller` derive for panicking `LazyEntity` methods
+
+### fixed
+
+- deadlock when despawning `MutableVec/Map`s during another `MutableVec/Map` despawn
+- initially empty `MutableVec/Map`s work as expected when output to `.switch_signal_vec/map`
+- `SignalVecExt::debug` and `SignalMapExt::debug` now log correct code location
+
 # 0.5.0 (2025-12-19)
 
 ### changed
diff --git a/src/builder.rs b/src/builder.rs
index 9ac0480..984c0f2 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -3495,4 +3495,225 @@ mod tests {
 
         cleanup()
     }
+
+    #[test]
+    fn test_on_despawn() {
+        // --- 1. Setup ---
+        let mut app = create_test_app();
+
+        // A resource to track whether the on_despawn callback was executed.
+        #[derive(Resource, Default, Clone)]
+        struct DespawnTracker(Arc<Mutex<Vec<(Entity, String)>>>);
+
+        app.init_resource::<DespawnTracker>();
+
+        // --- 2. Test Basic Callback Execution ---
+        let tracker = app.world().resource::<DespawnTracker>().clone();
+        let builder1 = JonmoBuilder::new().on_despawn({
+            let tracker = tracker.clone();
+            move |_world, entity| {
+                tracker.0.lock().unwrap().push((entity, "callback1".to_string()));
+            }
+        });
+
+        let entity1 = builder1.spawn(app.world_mut());
+        app.update();
+
+        // Callback should not have been called yet.
+        assert!(
+            tracker.0.lock().unwrap().is_empty(),
+            "on_despawn callback should not run before despawn."
+        );
+
+        // Despawn the entity.
+        app.world_mut().entity_mut(entity1).despawn();
+        app.update();
+
+        // Callback should have been called with the correct entity.
+        let tracker_guard = tracker.0.lock().unwrap();
+        assert_eq!(tracker_guard.len(), 1, "Callback should have been called exactly once.");
+        assert_eq!(tracker_guard[0], (entity1, "callback1".to_string()));
+        drop(tracker_guard);
+        tracker.0.lock().unwrap().clear();
+
+        // --- 3. Test Multiple Callbacks on Same Entity ---
+        let builder2 = JonmoBuilder::new()
+            .on_despawn({
+                let tracker = tracker.clone();
+                move |_world, entity| {
+                    tracker.0.lock().unwrap().push((entity, "first".to_string()));
+                }
+            })
+            .on_despawn({
+                let tracker = tracker.clone();
+                move |_world, entity| {
+                    tracker.0.lock().unwrap().push((entity, "second".to_string()));
+                }
+            })
+            .on_despawn({
+                let tracker = tracker.clone();
+                move |_world, entity| {
+                    tracker.0.lock().unwrap().push((entity, "third".to_string()));
+                }
+            });
+
+        let entity2 = builder2.spawn(app.world_mut());
+        app.update();
+
+        // Despawn the entity.
+        app.world_mut().entity_mut(entity2).despawn();
+        app.update();
+
+        // All three callbacks should have been called.
+        let tracker_guard = tracker.0.lock().unwrap();
+        assert_eq!(tracker_guard.len(), 3, "All three callbacks should have been called.");
+        // Callbacks are stored in a Vec and called in order.
+        assert_eq!(tracker_guard[0], (entity2, "first".to_string()));
+        assert_eq!(tracker_guard[1], (entity2, "second".to_string()));
+        assert_eq!(tracker_guard[2], (entity2, "third".to_string()));
+        drop(tracker_guard);
+        tracker.0.lock().unwrap().clear();
+
+        // --- 4. Test Multi-Entity Independence ---
+        let builder3 = JonmoBuilder::new().on_despawn({
+            let tracker = tracker.clone();
+            move |_world, entity| {
+                tracker.0.lock().unwrap().push((entity, "entity3".to_string()));
+            }
+        });
+        let entity3 = builder3.spawn(app.world_mut());
+
+        let builder4 = JonmoBuilder::new().on_despawn({
+            let tracker = tracker.clone();
+            move |_world, entity| {
+                tracker.0.lock().unwrap().push((entity, "entity4".to_string()));
+            }
+        });
+        let entity4 = builder4.spawn(app.world_mut());
+        app.update();
+
+        // Despawn only entity3.
+        app.world_mut().entity_mut(entity3).despawn();
+        app.update();
+
+        // Only entity3's callback should have been called.
+        let tracker_guard = tracker.0.lock().unwrap();
+        assert_eq!(tracker_guard.len(), 1, "Only one callback should have been called.");
+        assert_eq!(tracker_guard[0], (entity3, "entity3".to_string()));
+        drop(tracker_guard);
+        tracker.0.lock().unwrap().clear();
+
+        // Now despawn entity4.
+        app.world_mut().entity_mut(entity4).despawn();
+        app.update();
+
+        // entity4's callback should have been called.
+        let tracker_guard = tracker.0.lock().unwrap();
+        assert_eq!(tracker_guard.len(), 1, "entity4's callback should have been called.");
+        assert_eq!(tracker_guard[0], (entity4, "entity4".to_string()));
+        drop(tracker_guard);
+        tracker.0.lock().unwrap().clear();
+
+        // --- 5. Test DeferredWorld Access ---
+        // Verify that the callback can actually interact with the world.
+        #[derive(Resource, Default)]
+        struct DespawnCounter(u32);
+
+        app.init_resource::<DespawnCounter>();
+
+        let builder5 = JonmoBuilder::new().on_despawn(|world, _entity| {
+            world.resource_mut::<DespawnCounter>().0 += 1;
+        });
+
+        let entity5 = builder5.spawn(app.world_mut());
+        app.update();
+
+        assert_eq!(
+            app.world().resource::<DespawnCounter>().0,
+            0,
+            "Counter should be 0 before despawn."
+        );
+
+        app.world_mut().entity_mut(entity5).despawn();
+        app.update();
+
+        assert_eq!(
+            app.world().resource::<DespawnCounter>().0,
+            1,
+            "Counter should be incremented by on_despawn callback."
+        );
+
+        // Spawn and despawn another entity to verify counter increments again.
+        let builder6 = JonmoBuilder::new().on_despawn(|world, _entity| {
+            world.resource_mut::<DespawnCounter>().0 += 10;
+        });
+        let entity6 = builder6.spawn(app.world_mut());
+        app.update();
+        app.world_mut().entity_mut(entity6).despawn();
+        app.update();
+
+        assert_eq!(
+            app.world().resource::<DespawnCounter>().0,
+            11,
+            "Counter should be 1 + 10 = 11 after second despawn."
+        );
+
+        // --- 6. Test Combination with Other Builder Methods ---
+        // Ensure on_despawn works correctly with other builder methods like insert and child.
+        #[derive(Component)]
+        struct TestMarker;
+
+        let child_despawn_tracker = Arc::new(Mutex::new(Vec::new()));
+        let parent_despawn_tracker = Arc::new(Mutex::new(Vec::new()));
+
+        let child_tracker = child_despawn_tracker.clone();
+        let parent_tracker = parent_despawn_tracker.clone();
+
+        let builder_parent = JonmoBuilder::new()
+            .insert(TestMarker)
+            .on_despawn(move |_world, entity| {
+                parent_tracker.lock().unwrap().push(entity);
+            })
+            .child(JonmoBuilder::new().on_despawn(move |_world, entity| {
+                child_tracker.lock().unwrap().push(entity);
+            }));
+
+        let parent_entity = builder_parent.spawn(app.world_mut());
+        app.update();
+
+        // Get the child entity.
+        let children: Vec<Entity> = app
+            .world()
+            .get::<Children>(parent_entity)
+            .map(|c| c.iter().collect())
+            .unwrap_or_default();
+        assert_eq!(children.len(), 1, "Parent should have one child.");
+        let child_entity = children[0];
+
+        // Despawn the parent (which should also despawn the child due to Bevy's hierarchy).
+        app.world_mut().entity_mut(parent_entity).despawn();
+        app.update();
+
+        // Both callbacks should have been called.
+        assert_eq!(
+            parent_despawn_tracker.lock().unwrap().len(),
+            1,
+            "Parent's on_despawn should have been called."
+        );
+        assert_eq!(
+            parent_despawn_tracker.lock().unwrap()[0],
+            parent_entity,
+            "Parent callback should receive parent entity."
+        );
+        assert_eq!(
+            child_despawn_tracker.lock().unwrap().len(),
+            1,
+            "Child's on_despawn should have been called when parent is despawned."
+        );
+        assert_eq!(
+            child_despawn_tracker.lock().unwrap()[0],
+            child_entity,
+            "Child callback should receive child entity."
+        );
+    }
 }
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index 096575c..0f7a573 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -305,35 +305,30 @@ fn find_index<'a>(indices: impl Iterator<Item = &'a bool>, index: usize) -> usiz
     indices.take(index).filter(|x| **x).count()
 }
 
-/// Helper for `filter` - clones input to pass to system, returns original if predicate passes.
-fn filter_helper<T>(
-    world: &mut World,
-    diffs: Vec<VecDiff<T::Inner<'static>>>,
-    system: SystemId<T, bool>,
+/// Generic helper for filter/filter_map operations on VecDiff streams.
+/// `process` takes a value and returns `Option<O>` - `Some` means include, `None` means exclude.
+fn filter_generic_helper<T, O>(
+    diffs: Vec<VecDiff<T>>,
     indices: &mut Vec<bool>,
-) -> Option<Vec<VecDiff<T::Inner<'static>>>>
-where
-    T: SystemInput + 'static,
-    T::Inner<'static>: Clone,
-{
+    mut process: impl FnMut(T) -> Option<O>,
+) -> Option<Vec<VecDiff<O>>> {
     let mut output = vec![];
     for diff in diffs {
         let diff_option = match diff {
             VecDiff::Replace { values } => {
                 *indices = Vec::with_capacity(values.len());
-                let mut output = Vec::with_capacity(values.len());
+                let mut out_values = Vec::with_capacity(values.len());
                 for input in values {
-                    let include = world.run_system_with(system, input.clone()).unwrap_or(false);
-                    indices.push(include);
-                    if include {
-                        output.push(input);
+                    let mapped = process(input);
+                    indices.push(mapped.is_some());
+                    if let Some(value) = mapped {
+                        out_values.push(value);
                     }
                 }
-                Some(VecDiff::Replace { values: output })
+                Some(VecDiff::Replace { values: out_values })
             }
             VecDiff::InsertAt { index, value } => {
-                let include = world.run_system_with(system, value.clone()).unwrap_or(false);
-                if include {
+                if let Some(value) = process(value) {
                     indices.insert(index, true);
                     Some(VecDiff::InsertAt {
                         index: find_index(indices.iter(), index),
@@ -345,8 +340,7 @@ where
                 }
             }
             VecDiff::UpdateAt { index, value } => {
-                let include = world.run_system_with(system, value.clone()).unwrap_or(false);
-                if include {
+                if let Some(value) = process(value) {
                     if indices[index] {
                         Some(VecDiff::UpdateAt {
                             index: find_index(indices.iter(), index),
@@ -397,8 +391,7 @@ where
                 }
             }
             VecDiff::Push { value } => {
-                let include = world.run_system_with(system, value.clone()).unwrap_or(false);
-                if include {
+                if let Some(value) = process(value) {
                     indices.push(true);
                     Some(VecDiff::Push { value })
                 } else {
@@ -425,7 +418,25 @@ where
     if output.is_empty() { None } else { Some(output) }
 }
 
-/// Helper for `filter_map` - does NOT clone input, system takes ownership and returns mapped value.
+fn filter_helper<T>(
+    world: &mut World,
+    diffs: Vec<VecDiff<T::Inner<'static>>>,
+    system: SystemId<T, bool>,
+    indices: &mut Vec<bool>,
+) -> Option<Vec<VecDiff<T::Inner<'static>>>>
+where
+    T: SystemInput + 'static,
+    T::Inner<'static>: Clone,
+{
+    filter_generic_helper(diffs, indices, |value| {
+        if world.run_system_with(system, value.clone()).unwrap_or(false) {
+            Some(value)
+        } else {
+            None
+        }
+    })
+}
+
 fn filter_map_helper<T, O>(
     world: &mut World,
     diffs: Vec<VecDiff<T::Inner<'static>>>,
@@ -436,110 +447,9 @@ where
     T: SystemInput + 'static,
     O: 'static,
 {
-    let mut output = vec![];
-    for diff in diffs {
-        let diff_option = match diff {
-            VecDiff::Replace { values } => {
-                *indices = Vec::with_capacity(values.len());
-                let mut output = Vec::with_capacity(values.len());
-                for input in values {
-                    let mapped = world.run_system_with(system, input).ok().flatten();
-                    indices.push(mapped.is_some());
-                    if let Some(value) = mapped {
-                        output.push(value);
-                    }
-                }
-                Some(VecDiff::Replace { values: output })
-            }
-            VecDiff::InsertAt { index, value } => {
-                if let Some(value) = world.run_system_with(system, value).ok().flatten() {
-                    indices.insert(index, true);
-                    Some(VecDiff::InsertAt {
-                        index: find_index(indices.iter(), index),
-                        value,
-                    })
-                } else {
-                    indices.insert(index, false);
-                    None
-                }
-            }
-            VecDiff::UpdateAt { index, value } => {
-                if let Some(value) = world.run_system_with(system, value).ok().flatten() {
-                    if indices[index] {
-                        Some(VecDiff::UpdateAt {
-                            index: find_index(indices.iter(), index),
-                            value,
-                        })
-                    } else {
-                        indices[index] = true;
-                        Some(VecDiff::InsertAt {
-                            index: find_index(indices.iter(), index),
-                            value,
-                        })
-                    }
-                } else if indices[index] {
-                    indices[index] = false;
-                    Some(VecDiff::RemoveAt {
-                        index: find_index(indices.iter(), index),
-                    })
-                } else {
-                    None
-                }
-            }
-            VecDiff::Move { old_index, new_index } => {
-                // Determine if the item being moved is part of the filtered set.
-                let was_included = indices[old_index];
-
-                // Calculate the filtered old and new indices BEFORE and AFTER mutating `indices`.
-                let filtered_old_index = find_index(indices.iter(), old_index);
-                let temp_val = indices.remove(old_index);
-                indices.insert(new_index, temp_val);
-                let filtered_new_index = find_index(indices.iter(), new_index);
-
-                if was_included {
-                    Some(VecDiff::Move {
-                        old_index: filtered_old_index,
-                        new_index: filtered_new_index,
-                    })
-                } else {
-                    None
-                }
-            }
-            VecDiff::RemoveAt { index } => {
-                if indices.remove(index) {
-                    Some(VecDiff::RemoveAt {
-                        index: find_index(indices.iter(), index),
-                    })
-                } else {
-                    None
-                }
-            }
-            VecDiff::Push { value } => {
-                if let Some(value) = world.run_system_with(system, value).ok().flatten() {
-                    indices.push(true);
-                    Some(VecDiff::Push { value })
-                } else {
-                    indices.push(false);
-                    None
-                }
-            }
-            VecDiff::Pop => {
-                if indices.pop().expect("can't pop from empty vec") {
-                    Some(VecDiff::Pop)
-                } else {
-                    None
-                }
-            }
-            VecDiff::Clear => {
-                indices.clear();
-                Some(VecDiff::Clear)
-            }
-        };
-        if let Some(diff) = diff_option {
-            output.push(diff);
-        }
-    }
-    if output.is_empty() { None } else { Some(output) }
+    filter_generic_helper(diffs, indices, |value| {
+        world.run_system_with(system, value).ok().flatten()
+    })
 }
 
 /// Signal graph node which selectively forwards upstream [`Item`](SignalVec::Item)s, see

From 57112badba54b54256fcc1afb7d8bc842bca392f Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Thu, 25 Dec 2025 22:43:25 -0800
Subject: [PATCH 04/15] more

---
 CHANGELOG.md  | 1 +
 src/signal.rs | 4 ----
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fcc11d7..4654088 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 - removed output `Clone` bound from `SignalExt::filter_map`
 
 ### added
+- `SignalExt::take`
 - `track_caller` derive for panicking `LazyEntity` methods
 
 ### fixed
diff --git a/src/signal.rs b/src/signal.rs
index 2cd26ee..08c35d7 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -1485,8 +1485,6 @@ pub trait SignalExt: Signal {
     /// Outputs up to the first `count` values from this [`Signal`], and then terminates for all
     /// subsequent frames.
     ///
-    /// After `count` values are emitted, this signal will stop propagating any further values.
-    ///
     /// If `count` is `0`, this will never propagate any values.
     ///
     /// # Example
@@ -1522,8 +1520,6 @@ pub trait SignalExt: Signal {
 
     /// Outputs this [`Signal`]'s first value and then terminates for all subsequent frames.
     ///
-    /// After the first value is emitted, this signal will stop propagating any further values.
-    ///
     /// # Example
     ///
     /// ```

From d179e2728b2c25344d1464d99c3bd5884a8bb4bc Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Fri, 26 Dec 2025 00:33:30 -0800
Subject: [PATCH 05/15] add cloning warning for jonmobuilder

---
 src/builder.rs | 55 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 54 insertions(+), 1 deletion(-)

diff --git a/src/builder.rs b/src/builder.rs
index 984c0f2..3782899 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -13,6 +13,8 @@ use bevy_ecs::{
     system::{IntoObserverSystem, RunSystemOnce},
     world::DeferredWorld,
 };
+#[cfg(debug_assertions)]
+use bevy_log::warn;
 use bevy_platform::{
     prelude::*,
     sync::{Arc, Mutex},
@@ -31,13 +33,64 @@ use bevy_platform::{
 /// [`DomBuilder`](https://docs.rs/dominator/latest/dominator/struct.DomBuilder.html),
 /// and [haalka](https://github.com/databasedav/haalka)'s
 /// [`NodeBuilder`](https://docs.rs/haalka/latest/haalka/node_builder/struct.NodeBuilder.html).
-#[derive(Clone, Default)]
+///
+/// # `Clone` semantics
+///
+/// This type implements [`Clone`] **only** to satisfy trait bounds required by signal combinators.
+/// **Cloning [`JonmoBuilder`]s at runtime is a bug.** See [`JonmoBuilder::clone`] for
+/// details.
+#[derive(Default)]
 pub struct JonmoBuilder {
     #[allow(clippy::type_complexity)]
     on_spawns: Arc<Mutex<Vec<Box<dyn FnOnce(&mut World, Entity) + Send + Sync>>>>,
     child_block_populations: Arc<Mutex<Vec<usize>>>,
 }
 
+impl Clone for JonmoBuilder {
+    /// # Warning
+    ///
+    /// This clone implementation exists **only** to satisfy trait bounds required by signal
+    /// combinators (e.g., [`SignalExt::map`], [`SignalVecExt::filter_map`]). **Cloning
+    /// [`JonmoBuilder`]s at runtime is a bug and will lead to unexpected behavior.**
+    ///
+    /// Clones share internal on-spawn hooks via [`Arc`]. These hooks are one-shot ([`FnOnce`])
+    /// and are consumed when the builder is spawned. Spawning one clone will affect all other
+    /// clones.
+    ///
+    /// Use factory functions instead if you need reusable UI templates:
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// fn my_widget(label: &str) -> JonmoBuilder {
+    ///     JonmoBuilder::new().insert(Name::new(label.to_string()))
+    ///     // ... other configuration
+    /// }
+    ///
+    /// // Correct: each call creates a fresh builder
+    /// let mut world = World::new();
+    /// let widget1 = my_widget("First").spawn(&mut world);
+    /// let widget2 = my_widget("Second").spawn(&mut world);
+    /// ```
+    #[track_caller]
+    fn clone(&self) -> Self {
+        #[cfg(debug_assertions)]
+        warn!(
+            "Cloning `JonmoBuilder` at {} is a bug! `JonmoBuilder`'s `Clone` shares internal on-spawn \
+             hook queues via `Arc`. These hooks are one-shot (`FnOnce`) and are consumed on spawn. \
+             Spawning one clone will affect all other clones. Use factory functions instead if you \
+             need reusable UI templates.",
+            core::panic::Location::caller()
+        );
+
+        Self {
+            on_spawns: self.on_spawns.clone(),
+            child_block_populations: self.child_block_populations.clone(),
+        }
+    }
+}
+
 impl<T: Bundle> From<T> for JonmoBuilder {
     fn from(bundle: T) -> Self {
         Self::new().insert(bundle)

From 7f49ade83cbbf95edc1dfbef96f1447bebf9a30c Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Fri, 26 Dec 2025 00:38:17 -0800
Subject: [PATCH 06/15] update changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4654088..4f1d0f2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 ### added
 - `SignalExt::take`
 - `track_caller` derive for panicking `LazyEntity` methods
+- warning that cloning `JonmoBuilder`s at runtime is a bug
 
 ### fixed
 

From 102619ea00034826461618f3d3e443cc57754610 Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Sat, 27 Dec 2025 00:10:51 -0800
Subject: [PATCH 07/15] always warn

---
 src/builder.rs    | 2 --
 src/signal_vec.rs | 4 ++--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 3782899..f039569 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -13,7 +13,6 @@ use bevy_ecs::{
     system::{IntoObserverSystem, RunSystemOnce},
     world::DeferredWorld,
 };
-#[cfg(debug_assertions)]
 use bevy_log::warn;
 use bevy_platform::{
     prelude::*,
@@ -75,7 +74,6 @@ impl Clone for JonmoBuilder {
     /// ```
     #[track_caller]
     fn clone(&self) -> Self {
-        #[cfg(debug_assertions)]
         warn!(
             "Cloning `JonmoBuilder` at {} is a bug! `JonmoBuilder`'s `Clone` shares internal on-spawn \
              hook queues via `Arc`. These hooks are one-shot (`FnOnce`) and are consumed on spawn. \
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index 0f7a573..d494846 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -2483,7 +2483,7 @@ pub trait SignalVecExt: SignalVec {
     ///
     /// let mut world = World::new();
     /// let mut vec = MutableVecBuilder::from([1]).spawn(&mut world);
-    /// let signal = vec.signal_vec().is_empty();
+    /// let signal = vec.signal_vec().len();
     /// // `signal` outputs `1`
     /// vec.write(&mut world).pop();
     /// // `signal` outputs `0`
@@ -2508,7 +2508,7 @@ pub trait SignalVecExt: SignalVec {
     ///
     /// let mut world = World::new();
     /// let mut vec = MutableVecBuilder::from([1, 2, 3]).spawn(&mut world);
-    /// let signal = vec.signal_vec().is_empty();
+    /// let signal = vec.signal_vec().sum();
     /// // `signal` outputs `6`
     /// vec.write(&mut world).push(4);
     /// // `signal` outputs `10`

From 2ce66e099792f9a30fd98e1f34b598269490f0ee Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Thu, 15 Jan 2026 17:43:15 -0800
Subject: [PATCH 08/15] check before topo sort

---
 CHANGELOG.md      |    6 +-
 src/builder.rs    |    6 +-
 src/signal.rs     |  241 +++++--
 src/signal_map.rs |   13 +-
 src/signal_vec.rs | 1711 ++++++++++++++++++++++++++++++---------------
 5 files changed, 1336 insertions(+), 641 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4f1d0f2..0ba784e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,8 +16,8 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ### fixed
 
-- deadlock when despawning `MutableVec/Map`s during another `MutableVec/Map` despawn
-- initially empty `MutableVec/Map`s work as expected when output to `.switch_signal_vec/map`
+- deadlock when despawning `MutableVec/BTreeMap`s during another `MutableVec/BTreeMap` despawn
+- initially empty `MutableVec/BTreeMap`s work as expected when output to `.switch_signal_vec/map`
 - `SignalVecExt::debug` and `SignalMapExt::debug` now log correct code location
 
 # 0.5.0 (2025-12-19)
@@ -25,7 +25,7 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 ### changed
 
 - `.entity_sync` renamed to `.lazy_entity`
-- `SignalExt::combine` always `.clone`s its latest upstream outputs instead of `.take`-ing them
+- `SignalExt::combine` emits its latest upstream outputs every frame, unlike previously, when it only emitted on frames where the latest output pair was yet to be emitted
 
 ### added
 
diff --git a/src/builder.rs b/src/builder.rs
index f039569..184d142 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -29,9 +29,7 @@ use bevy_platform::{
 /// `&mut World` or [`Commands`].
 ///
 /// Port of [Dominator](https://github.com/Pauan/rust-dominator)'s
-/// [`DomBuilder`](https://docs.rs/dominator/latest/dominator/struct.DomBuilder.html),
-/// and [haalka](https://github.com/databasedav/haalka)'s
-/// [`NodeBuilder`](https://docs.rs/haalka/latest/haalka/node_builder/struct.NodeBuilder.html).
+/// [`DomBuilder`](https://docs.rs/dominator/latest/dominator/struct.DomBuilder.html).
 ///
 /// # `Clone` semantics
 ///
@@ -2009,7 +2007,7 @@ mod tests {
         let signal_factory = |entity_signal: crate::signal::Source<Entity>| {
             // Combine the entity signal with the global source signal.
             entity_signal
-                .combine(SignalBuilder::from_resource::<SignalSource>().dedupe())
+                .with(SignalBuilder::from_resource::<SignalSource>().dedupe())
                 // The `.map` combinator gives us access to other `SystemParam`s, like `Query`.
                 .map(
                     |In((entity, source)): In<(Entity, SignalSource)>, names: Query<&Name>| {
diff --git a/src/signal.rs b/src/signal.rs
index 08c35d7..a542e11 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -346,8 +346,8 @@ where
     }
 }
 
-/// Signal graph node which combines two upstreams, see [`.combine`](SignalExt::combine).
-pub struct Combine<Left, Right>
+/// Signal graph node which combines two upstreams, see [`.with`](SignalExt::with).
+pub struct With<Left, Right>
 where
     Left: Signal,
     Right: Signal,
@@ -359,7 +359,7 @@ where
     signal: LazySignal,
 }
 
-impl<Left, Right> Clone for Combine<Left, Right>
+impl<Left, Right> Clone for With<Left, Right>
 where
     Left: Signal + Clone,
     Right: Signal + Clone,
@@ -373,7 +373,7 @@ where
     }
 }
 
-impl<Left, Right> Signal for Combine<Left, Right>
+impl<Left, Right> Signal for With<Left, Right>
 where
     Left: Signal,
     Right: Signal,
@@ -509,11 +509,6 @@ where
     }
 }
 
-#[derive(Component)]
-struct FlattenState<T> {
-    value: Option<T>,
-}
-
 /// Signal graph node which forwards the upstream output [`Signal`]'s output, see
 /// [`.flatten`](SignalExt::flatten).
 pub struct Flatten<Upstream>
@@ -1662,9 +1657,9 @@ pub trait SignalExt: Signal {
     ///
     /// let signal_1 = SignalBuilder::from_system(|_: In<()>| 1);
     /// let signal_2 = SignalBuilder::from_system(|_: In<()>| 2);
-    /// signal_1.combine(signal_2); // outputs `(1, 2)`
+    /// signal_1.with(signal_2); // outputs `(1, 2)`
     /// ```
-    fn combine<Other>(self, other: Other) -> Combine<Self, Other>
+    fn with<Other>(self, other: Other) -> With<Self, Other>
     where
         Self: Sized,
         Other: Signal,
@@ -1691,7 +1686,7 @@ pub trait SignalExt: Signal {
                 }
             },
         );
-        Combine {
+        With {
             left_wrapper,
             right_wrapper,
             signal,
@@ -1732,14 +1727,18 @@ pub trait SignalExt: Signal {
         Self::Item: Signal + Clone + 'static,
         <Self::Item as Signal>::Item: Clone + Send + Sync,
     {
+        #[derive(Component)]
+        struct FlattenState<T> {
+            value: Option<T>,
+        }
+
         let signal = LazySignal::new(move |world: &mut World| {
-            // 1. The state entity that holds the latest value. This is the communication channel between the
-            //    dynamic inner signals and the static output signal.
+            // 1. State entity that holds the latest value, serving as the communication channel
+            //    between dynamic inner signals and the static output signal.
             let reader_entity = LazyEntity::new();
 
-            // 2. The final output signal (reader). Its ONLY job is to read the state component and propagate
-            //    the value. It has no upstream dependencies in the graph; it is triggered manually by the
-            //    forwarder.
+            // 2. The output signal (reader). Reads from state and propagates. Has no upstream
+            //    dependencies; triggered manually by the forwarder.
             let reader_system = *SignalBuilder::from_system::<<Self::Item as Signal>::Item, _, _, _>(
                     clone!((reader_entity) move |_: In<()>, mut query: Query<&mut FlattenState<<Self::Item as Signal>::Item>, Allow<Internal>>| {
                         if let Ok(mut state) = query.get_mut(reader_entity.get()) {
@@ -1755,45 +1754,32 @@ pub trait SignalExt: Signal {
                 .entity_mut(*reader_system)
                 .insert(FlattenState::<<Self::Item as Signal>::Item> { value: None });
 
-            // 3. This is the "subscription manager" system. It reacts to the outer signal emitting new inner
-            //    signals.
+            // 3. The subscription manager. Reacts to the outer signal emitting new inner signals.
             let manager_system = self
                 .map(
-                    // This closure contains the core logic for switching subscriptions.
                     move |In(inner_signal): In<Self::Item>,
                           world: &mut World,
                           mut active_forwarder: Local<Option<SignalHandle>>,
                           mut active_signal_id: Local<Option<SignalSystem>>| {
-                        // A. Get the canonical ID of the newly emitted inner signal. `register` is
-                        // idempotent; it just increments the ref-count if the system exists.
+                        // a. Get the canonical ID. `register` is idempotent for existing signals.
                         let new_signal_id = inner_signal.clone().register(world);
 
-                        // B. MEMOIZATION: Check if the signal has actually changed from the last frame.
+                        // b. Memoization: if unchanged, balance the ref-count and return early.
                         if Some(*new_signal_id) == *active_signal_id {
-                            // The signal is the same. Do nothing. IMPORTANT: We must cleanup the handle from
-                            // our `.register()` call above to balance the reference count, otherwise it will
-                            // leak.
                             new_signal_id.cleanup(world);
                             return;
                         }
 
-                        // C. TEARDOWN: The signal is new, so clean up the old forwarder and its ID.
+                        // c. Clean up the old forwarder.
                         if let Some(old_handle) = active_forwarder.take() {
                             old_handle.cleanup(world);
                         }
 
-                        // The old signal ID handle is implicitly dropped when overwritten.
-                        // ================== The Core Setup Logic for the NEW Signal ==================
-                        // D. Get the initial value of the new inner signal, synchronously. This is done
-                        // by creating a temporary one-shot signal.
-                        let temp_handle = inner_signal.clone().first().register(world);
-                        let initial_value = poll_signal(world, *temp_handle)
+                        // d. Poll the initial value synchronously.
+                        let initial_value = poll_signal(world, *new_signal_id)
                             .and_then(downcast_any_clone::<<Self::Item as Signal>::Item>);
 
-                        // The temporary handle must be cleaned up immediately.
-                        temp_handle.cleanup(world);
-
-                        // E. Write this initial value directly into the state component.
+                        // e. Write initial value to state.
                         if let Some(value) = initial_value
                             && let Some(mut state) =
                                 world.get_mut::<FlattenState<<Self::Item as Signal>::Item>>(*reader_system)
@@ -1801,42 +1787,29 @@ pub trait SignalExt: Signal {
                             state.value = Some(value);
                         }
 
-                        // F. Set up a persistent forwarder for all _subsequent_ updates from the new
-                        // signal.
+                        // f. Set up forwarder for subsequent values.
                         let forwarder_handle = inner_signal
-                            .map(
-                                // This first map writes the value to the state component.
-                                move |In(value),
-                                      mut query: Query<
-                                    &mut FlattenState<<Self::Item as Signal>::Item>,
-                                    Allow<Internal>,
-                                >| {
-                                    if let Ok(mut state) = query.get_mut(*reader_system) {
-                                        state.value = Some(value);
-                                    }
-                                },
-                            )
-                            .map(
-                                // This second map triggers the reader to run immediately after the state is
-                                // written.
-                                move |_, world: &mut World| {
-                                    process_signals(world, [reader_system], Box::new(()));
-                                },
-                            )
+                            .map(move |In(value), world: &mut World| {
+                                if let Some(mut state) =
+                                    world.get_mut::<FlattenState<<Self::Item as Signal>::Item>>(*reader_system)
+                                {
+                                    state.value = Some(value);
+                                }
+                                process_signals(world, [reader_system], Box::new(()));
+                            })
                             .register(world);
 
-                        // G. Store the new forwarder's handle and the new signal's ID for the next frame.
+                        // g. Store handles for next frame's memoization check.
                         *active_forwarder = Some(forwarder_handle);
                         *active_signal_id = Some(*new_signal_id);
 
-                        // H. Manually trigger the reader to run RIGHT NOW to consume the initial value.
+                        // h. Trigger reader to consume the initial value.
                         process_signals(world, [reader_system], Box::new(()));
                     },
                 )
                 .register(world);
 
-            // 4. Set up entity hierarchy for automatic cleanup. When the `reader_system` (the final output) is
-            //    cleaned up, it will also despawn its children.
+            // 4. Entity hierarchy for automatic cleanup.
             world
                 .entity_mut(*reader_system)
                 .insert(SignalHandles::from([manager_system]));
@@ -2887,7 +2860,7 @@ impl<T: ?Sized> SignalExt for T where T: Signal {}
 macro_rules! eq {
     // Entry point
     ($s1:expr, $s2:expr $(, $rest:expr)* $(,)?) => {
-        $crate::__signal_combine_and_map!($s1, $s2 $(, $rest)*; |val| {
+        $crate::__signal_with_and_map!($s1, $s2 $(, $rest)*; |val| {
             $crate::eq!(@check val, $s1, $s2 $(, $rest)*)
         })
     };
@@ -2905,32 +2878,32 @@ macro_rules! eq {
 
 #[doc(hidden)]
 #[macro_export]
-macro_rules! __signal_combine_and_map {
+macro_rules! __signal_with_and_map {
     // Single argument case
     ($s1:expr $(,)?; |$val:ident| $body:block) => {
         $s1.map(|In($val)| $body)
     };
     // Entry point
     ($s1:expr, $s2:expr $(, $rest:expr)* $(,)?; |$val:ident| $body:block) => {
-        $crate::__signal_combine_and_map!(@combine $s1, $s2 $(, $rest)*)
-            .map(|In($val @ $crate::__signal_combine_and_map!(@pattern $s1, $s2 $(, $rest)*))| $body)
+        $crate::__signal_with_and_map!(@combine $s1, $s2 $(, $rest)*)
+            .map(|In($val @ $crate::__signal_with_and_map!(@pattern $s1, $s2 $(, $rest)*))| $body)
     };
 
     // Combine chain
     (@combine $first:expr, $second:expr) => {
-        $first.combine($second)
+        $first.with($second)
     };
     (@combine $first:expr, $second:expr, $($rest:expr),+) => {
-        $crate::__signal_combine_and_map!(@combine $first.combine($second), $($rest),+)
+        $crate::__signal_with_and_map!(@combine $first.with($second), $($rest),+)
     };
 
     // Pattern generator (nested tuple of `_` matching the combine nesting)
     (@pattern $s1:expr, $s2:expr $(, $rest:expr)*) => {
-        $crate::__signal_combine_and_map!(@pattern_helper (_, _) $(, $rest)*)
+        $crate::__signal_with_and_map!(@pattern_helper (_, _) $(, $rest)*)
     };
     (@pattern_helper $acc:tt $(,)?) => { $acc };
     (@pattern_helper $acc:tt, $head:expr $(, $tail:expr)*) => {
-        $crate::__signal_combine_and_map!(@pattern_helper ($acc, _) $(, $tail)*)
+        $crate::__signal_with_and_map!(@pattern_helper ($acc, _) $(, $tail)*)
     };
 }
 
@@ -3070,7 +3043,7 @@ macro_rules! __signal_reduce_binop {
     };
     // Entry point
     ($op:tt; $s1:expr, $s2:expr $(, $rest:expr)* $(,)?) => {
-        $crate::__signal_combine_and_map!($s1, $s2 $(, $rest)*; |val| {
+        $crate::__signal_with_and_map!($s1, $s2 $(, $rest)*; |val| {
             $crate::__signal_reduce_binop!(@apply $op, val, $s1, $s2 $(, $rest)*)
         })
     };
@@ -3166,7 +3139,7 @@ macro_rules! __signal_reduce_cmp {
     };
     // Entry point
     ($cmp:tt; $s1:expr, $s2:expr $(, $rest:expr)* $(,)?) => {
-        $crate::__signal_combine_and_map!($s1, $s2 $(, $rest)*; |val| {
+        $crate::__signal_with_and_map!($s1, $s2 $(, $rest)*; |val| {
             $crate::__signal_reduce_cmp!(@select $cmp, val, $s1, $s2 $(, $rest)*)
         })
     };
@@ -3185,6 +3158,68 @@ macro_rules! __signal_reduce_cmp {
     };
 }
 
+/// Zips multiple [`Signal`]s into a single [`Signal`] that outputs a flat tuple of all their
+/// outputs. Unlike chaining [`.with()`](SignalExt::with) calls which produces nested tuples
+/// like `(((A, B), C), D)`, this macro produces flat tuples like `(A, B, C, D)`.
+///
+/// The resulting [`Signal`] will only output a value when all input [`Signal`]s have outputted a
+/// value.
+///
+/// Accepts 1 or more [`Signal`]s.
+///
+/// # Example
+///
+/// ```
+/// use bevy_ecs::prelude::*;
+/// use jonmo::{prelude::*, signal};
+///
+/// let s1 = SignalBuilder::from_system(|_: In<()>| 1);
+/// let s2 = SignalBuilder::from_system(|_: In<()>| "hello");
+/// let s3 = SignalBuilder::from_system(|_: In<()>| 3.14);
+/// let s4 = SignalBuilder::from_system(|_: In<()>| true);
+///
+/// // Outputs a flat tuple (i32, &str, f64, bool)
+/// let zipped = signal::zip!(s1, s2, s3, s4);
+///
+/// // Compare to chained .with() which would give (((i32, &str), f64), bool)
+/// ```
+#[macro_export]
+macro_rules! zip {
+    // Single signal case - just return it as-is wrapped in a 1-tuple for consistency
+    ($s1:expr $(,)?) => {
+        $s1.map(|In(__v)| (__v,))
+    };
+    // Two signals - use with directly (already flat)
+    ($s1:expr, $s2:expr $(,)?) => {
+        $s1.with($s2)
+    };
+    // Three or more signals - build combine chain then flatten
+    ($s1:expr, $s2:expr $(, $rest:expr)+ $(,)?) => {
+        $crate::__signal_with_and_map!($s1, $s2 $(, $rest)+; |__v| {
+            $crate::__signal_zip_flatten!(__v; $s1, $s2 $(, $rest)+;)
+        })
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __signal_zip_flatten {
+    // Entry point - start building from innermost (.0.0...) outward
+    ($val:expr; $($signals:expr),+;) => {
+        $crate::__signal_zip_flatten!(@collect $val; $($signals),+; ())
+    };
+
+    // Base case: 2 signals left - prepend val.0, val.1 to accumulator
+    (@collect $val:expr; $s1:expr, $s2:expr; ($($acc:expr),*)) => {
+        ($val.0, $val.1 $(, $acc)*)
+    };
+
+    // Recursive case: 3+ signals - add val.1 to accumulator, recurse with val.0
+    (@collect $val:expr; $head:expr, $($tail:expr),+; ($($acc:expr),*)) => {
+        $crate::__signal_zip_flatten!(@collect $val.0; $($tail),+; ($val.1 $(, $acc)*))
+    };
+}
+
 pub use all;
 pub use any;
 pub use distinct;
@@ -3193,6 +3228,7 @@ pub use max;
 pub use min;
 pub use product;
 pub use sum;
+pub use zip;
 
 #[cfg(test)]
 mod tests {
@@ -3673,11 +3709,11 @@ mod tests {
     }
 
     #[test]
-    fn test_combine() {
+    fn test_with() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<(i32, &'static str)>>();
         let signal = SignalBuilder::from_system(move |_: In<()>| 10)
-            .combine(SignalBuilder::from_system(move |_: In<()>| "hello"))
+            .with(SignalBuilder::from_system(move |_: In<()>| "hello"))
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -3685,6 +3721,63 @@ mod tests {
         signal.cleanup(app.world_mut());
     }
 
+    #[test]
+    fn test_zip_macro() {
+        use crate::signal::zip;
+
+        let mut app = create_test_app();
+
+        // Test 1 signal - returns 1-tuple
+        app.init_resource::<SignalOutput<(i32,)>>();
+        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
+        let signal = zip!(s1).map(capture_output).register(app.world_mut());
+        app.update();
+        assert_eq!(get_output::<(i32,)>(app.world()), Some((1,)));
+        signal.cleanup(app.world_mut());
+
+        // Test 2 signals - same as .with()
+        app.init_resource::<SignalOutput<(i32, &'static str)>>();
+        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
+        let s2 = SignalBuilder::from_system(|_: In<()>| "two");
+        let signal = zip!(s1, s2).map(capture_output).register(app.world_mut());
+        app.update();
+        assert_eq!(get_output::<(i32, &'static str)>(app.world()), Some((1, "two")));
+        signal.cleanup(app.world_mut());
+
+        // Test 3 signals - flat tuple (not nested)
+        app.init_resource::<SignalOutput<(i32, &'static str, f64)>>();
+        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
+        let s2 = SignalBuilder::from_system(|_: In<()>| "two");
+        let s3 = SignalBuilder::from_system(|_: In<()>| 3.0);
+        let signal = zip!(s1, s2, s3).map(capture_output).register(app.world_mut());
+        app.update();
+        assert_eq!(get_output::<(i32, &'static str, f64)>(app.world()), Some((1, "two", 3.0)));
+        signal.cleanup(app.world_mut());
+
+        // Test 4 signals - verifies flattening works for more signals
+        app.init_resource::<SignalOutput<(i32, &'static str, f64, bool)>>();
+        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
+        let s2 = SignalBuilder::from_system(|_: In<()>| "two");
+        let s3 = SignalBuilder::from_system(|_: In<()>| 3.0);
+        let s4 = SignalBuilder::from_system(|_: In<()>| true);
+        let signal = zip!(s1, s2, s3, s4).map(capture_output).register(app.world_mut());
+        app.update();
+        assert_eq!(get_output::<(i32, &'static str, f64, bool)>(app.world()), Some((1, "two", 3.0, true)));
+        signal.cleanup(app.world_mut());
+
+        // Test 5 signals - ensures unlimited recursion works
+        app.init_resource::<SignalOutput<(i32, i32, i32, i32, i32)>>();
+        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
+        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
+        let s3 = SignalBuilder::from_system(|_: In<()>| 3);
+        let s4 = SignalBuilder::from_system(|_: In<()>| 4);
+        let s5 = SignalBuilder::from_system(|_: In<()>| 5);
+        let signal = zip!(s1, s2, s3, s4, s5).map(capture_output).register(app.world_mut());
+        app.update();
+        assert_eq!(get_output::<(i32, i32, i32, i32, i32)>(app.world()), Some((1, 2, 3, 4, 5)));
+        signal.cleanup(app.world_mut());
+    }
+
     #[test]
     fn test_flatten() {
         let mut app = create_test_app();
diff --git a/src/signal_map.rs b/src/signal_map.rs
index 587f8a3..784606e 100644
--- a/src/signal_map.rs
+++ b/src/signal_map.rs
@@ -22,7 +22,7 @@ use core::{
     fmt,
     marker::PhantomData,
     ops::Deref,
-    sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering},
+    sync::atomic::{AtomicUsize, Ordering as AtomicOrdering},
 };
 use dyn_clone::{DynClone, clone_trait_object};
 
@@ -611,6 +611,9 @@ pub trait SignalMapExt: SignalMap {
         S::Item: Clone + SSs,
         F: IntoSystem<In<Self::Value>, S, M> + SSs,
     {
+        #[derive(Component)]
+        struct QueuedMapDiffs<K, V>(Vec<MapDiff<K, V>>);
+
         let signal = LazySignal::new(move |world: &mut World| {
             let factory_system_id = world.register_system(system);
             let output_signal_entity = LazyEntity::new();
@@ -1075,9 +1078,6 @@ pub struct MutableBTreeMapData<K, V> {
     broadcaster: LazySignal,
 }
 
-#[derive(Component)]
-struct QueuedMapDiffs<K, V>(Vec<MapDiff<K, V>>);
-
 /// Wrapper around a [`BTreeMap`] that emits mutations as [`MapDiff`]s, enabling diff-less
 /// constant-time reactive updates for downstream [`SignalMap`]s.
 pub struct MutableBTreeMap<K, V> {
@@ -1214,10 +1214,9 @@ impl<K, V> MutableBTreeMap<K, V> {
             let was_initially_empty = self_.read(&*world).is_empty();
 
             let replay_entity = LazyEntity::new();
-            let is_first_replay = Arc::new(AtomicBool::new(true));
-            let replay_system = clone!((self_, replay_entity, is_first_replay) move |In(upstream_diffs): In<Vec<MapDiff<K, V>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_btree_map_datas: Query<&MutableBTreeMapData<K, V>>| {
+            let replay_system = clone!((self_, replay_entity) move |In(upstream_diffs): In<Vec<MapDiff<K, V>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_btree_map_datas: Query<&MutableBTreeMapData<K, V>>, mut has_replayed: Local<bool>| {
                 if replay_onces.contains(*replay_entity) {
-                    let first_replay = is_first_replay.swap(false, AtomicOrdering::SeqCst);
+                    let first_replay = !core::mem::replace(&mut *has_replayed, true);
                     if first_replay && was_initially_empty {
                         // Initial replay with empty map - just forward upstream diffs
                         if upstream_diffs.is_empty() {
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index d494846..f5c85f3 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -14,7 +14,7 @@ use bevy_ecs::{change_detection::Mut, entity_disabling::Internal, prelude::*, sy
 #[cfg(feature = "tracing")]
 use bevy_log::debug;
 use bevy_platform::{
-    collections::HashMap,
+    collections::{HashMap, HashSet},
     prelude::*,
     sync::{Arc, LazyLock, Mutex},
 };
@@ -23,7 +23,7 @@ use core::{
     fmt,
     marker::PhantomData,
     ops::Deref,
-    sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering},
+    sync::atomic::{AtomicUsize, Ordering as AtomicOrdering},
 };
 use dyn_clone::{DynClone, clone_trait_object};
 
@@ -268,9 +268,6 @@ where
     }
 }
 
-#[derive(Component, Deref, DerefMut, Clone, Copy)]
-struct ItemIndex(usize);
-
 /// Signal graph node which applies a [`System`] to each [`Item`](SignalVec::Item) of its upstream,
 /// forwarding the output of each resulting [`Signal`], see
 /// [`.map_signal`](SignalVecExt::map_signal).
@@ -513,109 +510,6 @@ where
     }
 }
 
-struct FilterSignalItem<T> {
-    signal: SignalHandle,
-    value: T,
-    filtered: bool,
-}
-
-#[derive(Component)]
-struct FilterSignalData<T> {
-    items: Vec<FilterSignalItem<T>>,
-    diffs: Vec<VecDiff<T>>,
-}
-
-fn with_filter_signal_data<T: SSs, O>(
-    world: &mut World,
-    entity: Entity,
-    f: impl FnOnce(Mut<FilterSignalData<T>>) -> O,
-) -> O {
-    let data = world.get_mut::<FilterSignalData<T>>(entity).unwrap();
-    f(data)
-}
-
-fn find_filter_signal_index<T>(filter_signal_items: &[FilterSignalItem<T>], i: usize) -> usize {
-    find_index(filter_signal_items.iter().map(|signal| &signal.filtered), i)
-}
-
-#[derive(Component, Deref, DerefMut)]
-struct FilterSignalIndex(usize);
-
-fn spawn_filter_signal<T: Clone + SSs>(
-    world: &mut World,
-    index: usize,
-    signal: impl Signal<Item = bool> + 'static,
-    parent: Entity,
-) -> (SignalHandle, bool) {
-    let entity = LazyEntity::new();
-    let processor_system = clone!((entity) move |In(filter): In<bool>, world: &mut World| {
-        let self_entity = *entity;
-
-        // The processor might run after its parent has been cleaned up.
-        let Ok(signal_index_comp) = world.query_filtered::<&FilterSignalIndex, Allow<Internal>>().get(world, self_entity) else {
-            return;
-        };
-        let item_index = signal_index_comp.0;
-        let Ok(mut filter_signal_data) = world.query_filtered::<&mut FilterSignalData<T>, Allow<Internal>>().get_mut(world, parent) else {
-            return;
-        };
-
-        // This item_index might be stale if other items were removed in the same frame.
-        // Ensure we don't panic.
-        if item_index >= filter_signal_data.items.len() {
-            return;
-        }
-        let old_filtered_state = filter_signal_data.items[item_index].filtered;
-        if old_filtered_state == filter {
-            // No change, do nothing.
-            return;
-        }
-        let diff_to_queue = if filter {
-            // Item is now INCLUDED. Find its insertion point based on the state _before_ it's
-            // marked as included.
-            let new_filtered_index = find_filter_signal_index(&filter_signal_data.items, item_index);
-            filter_signal_data.items[item_index].filtered = true;
-            VecDiff::InsertAt {
-                index: new_filtered_index,
-                value: filter_signal_data.items[item_index].value.clone(),
-            }
-        } else {
-            // Item is now EXCLUDED. Find its removal point based on the state _before_ it's
-            // marked as excluded.
-            let old_filtered_index = find_filter_signal_index(&filter_signal_data.items, item_index);
-            filter_signal_data.items[item_index].filtered = false;
-            VecDiff::RemoveAt { index: old_filtered_index }
-        };
-        filter_signal_data.diffs.push(diff_to_queue);
-
-        // Poke the main output signal to process its queue immediately.
-        process_signals(world, [parent.into()], Box::new(Vec::<VecDiff<T>>::new()));
-    });
-
-    // Use .map() to attach the processor. The dedupe is still important.
-    let mapped_signal = signal.dedupe().map(processor_system);
-    let handle = mapped_signal.register(world);
-    entity.set(**handle);
-    world.entity_mut(**handle).insert(FilterSignalIndex(index));
-
-    // To get the initial value, we must poll the original signal before the
-    // map/dedupe. The upstream of the `map` node is the `dedupe` node.
-    let dedupe_handle = world.get::<Upstream>(**handle).unwrap().iter().next().cloned().unwrap();
-
-    // The upstream of the `dedupe` node is the original signal.
-    let original_signal_handle = world
-        .get::<Upstream>(*dedupe_handle)
-        .unwrap()
-        .iter()
-        .next()
-        .cloned()
-        .unwrap();
-    let initial_value = poll_signal(world, original_signal_handle)
-        .and_then(downcast_any_clone::<bool>)
-        .expect("filter_signal's inner signal must emit an initial value upon registration");
-    (handle, initial_value)
-}
-
 /// Signal graph node which selectively forwards upstream [`Item`](SignalVec::Item)s depending on a
 /// [`Signal<Item = bool>`], see [`.filter_signal`](SignalVecExt::filter_signal).
 pub struct FilterSignal<Upstream> {
@@ -643,13 +537,6 @@ where
     }
 }
 
-#[derive(Component, Default)]
-struct EnumerateState {
-    key_to_index: HashMap<usize, usize>,
-    ordered_keys: Vec<usize>,
-    next_key: usize,
-}
-
 /// Signal graph node which prepends an index signal to each upstream [`Item`](SignalVec::Item), see
 /// [`.enumerate`](SignalVecExt::enumerate).
 pub struct Enumerate<Upstream>
@@ -902,30 +789,6 @@ where
     }
 }
 
-#[derive(Component)]
-struct IntersperseState<T> {
-    /// The original, non-interspersed values. We need this to know the length.
-    local_values: Vec<T>,
-    /// Stable keys for the separators. The key at index `i` corresponds to the separator that comes
-    /// _after_ `local_values[i]`.
-    separator_keys: Vec<usize>,
-    /// Maps a separator's stable key to its current logical index (0, 1, 2...).
-    key_to_index: HashMap<usize, usize>,
-    /// A counter to generate new unique, stable keys.
-    next_key: usize,
-}
-
-impl<T> Default for IntersperseState<T> {
-    fn default() -> Self {
-        Self {
-            local_values: Vec::new(),
-            separator_keys: Vec::new(),
-            key_to_index: HashMap::new(),
-            next_key: 0,
-        }
-    }
-}
-
 /// Signal graph node that places a [`System`]-dependent separator between each upstream
 /// [`Item`](SignalVec::Item), see [`.intersperse_with`](SignalVecExt::intersperse_with).
 pub struct IntersperseWith<Upstream> {
@@ -1007,163 +870,6 @@ where
     }
 }
 
-/*
-struct FlattenItem<O: SSs + Clone> {
-    processor_handle: SignalHandle,
-    values: Vec<O>,
-    _marker: PhantomData<fn() -> O>,
-}
-
-#[derive(Component)]
-struct FlattenData<O: SSs + Clone> {
-    items: Vec<FlattenItem<O>>,
-    diffs: Vec<VecDiff<O>>,
-}
-
-fn with_flatten_data<O: SSs + Clone, R>(
-    world: &mut World,
-    parent: Entity,
-    f: impl FnOnce(Mut<FlattenData<O>>) -> R,
-) -> R {
-    f(world.get_mut::<FlattenData<O>>(parent).unwrap())
-}
-
-#[derive(Component, Deref, DerefMut)]
-struct FlattenInnerIndex(usize);
-
-#[allow(clippy::type_complexity)]
-fn create_flatten_processor<O: Clone + SSs>(
-    entity: LazyEntity,
-    parent: Entity,
-) -> impl Fn(In<Vec<VecDiff<O>>>, Query<&FlattenInnerIndex>, Query<&mut FlattenData<O>>) {
-    move |In(diffs): In<Vec<VecDiff<O>>>,
-          query_self_index: Query<&FlattenInnerIndex>,
-          mut query_parent_data: Query<&mut FlattenData<O>>| {
-        if let Ok(mut parent_data) = query_parent_data.get_mut(parent) {
-            if let Ok(&FlattenInnerIndex(self_index)) = query_self_index.get(entity.get()) {
-                if self_index >= parent_data.items.len() {
-                    return;
-                }
-
-                let offset: usize = parent_data.items[..self_index]
-                    .iter()
-                    .map(|item| item.values.len())
-                    .sum();
-
-                for diff in diffs {
-                    let apply_and_queue = |pd: &mut Mut<FlattenData<O>>, d: VecDiff<O>| {
-                        let translated_diff = match d {
-                            VecDiff::Replace { values } => {
-                                let old_len = pd.items[self_index].values.len();
-                                for _ in 0..old_len {
-                                    pd.diffs.push(VecDiff::RemoveAt { index: offset });
-                                }
-                                for (i, v) in values.iter().enumerate() {
-                                    pd.diffs.push(VecDiff::InsertAt {
-                                        index: offset + i,
-                                        value: v.clone(),
-                                    });
-                                }
-                                pd.items[self_index].values = values;
-                                return;
-                            }
-                            VecDiff::InsertAt { index, value } => {
-                                pd.items[self_index].values.insert(index, value.clone());
-                                VecDiff::InsertAt {
-                                    index: index + offset,
-                                    value,
-                                }
-                            }
-                            VecDiff::UpdateAt { index, value } => {
-                                pd.items[self_index].values[index] = value.clone();
-                                VecDiff::UpdateAt {
-                                    index: index + offset,
-                                    value,
-                                }
-                            }
-                            VecDiff::RemoveAt { index } => {
-                                pd.items[self_index].values.remove(index);
-                                VecDiff::RemoveAt {
-                                    index: index + offset,
-                                }
-                            }
-                            VecDiff::Move {
-                                old_index,
-                                new_index,
-                            } => {
-                                let val = pd.items[self_index].values.remove(old_index);
-                                pd.items[self_index].values.insert(new_index, val);
-                                VecDiff::Move {
-                                    old_index: old_index + offset,
-                                    new_index: new_index + offset,
-                                }
-                            }
-                            VecDiff::Push { value } => {
-                                let old_len = pd.items[self_index].values.len();
-                                pd.items[self_index].values.push(value.clone());
-                                VecDiff::InsertAt {
-                                    index: offset + old_len,
-                                    value,
-                                }
-                            }
-                            VecDiff::Pop => {
-                                pd.items[self_index].values.pop();
-                                VecDiff::RemoveAt {
-                                    index: offset + pd.items[self_index].values.len(),
-                                }
-                            }
-                            VecDiff::Clear => {
-                                let old_len = pd.items[self_index].values.len();
-                                pd.items[self_index].values.clear();
-                                for _ in 0..old_len {
-                                    pd.diffs.push(VecDiff::RemoveAt { index: offset });
-                                }
-                                return;
-                            }
-                        };
-                        pd.diffs.push(translated_diff);
-                    };
-                    apply_and_queue(&mut parent_data, diff);
-                }
-            }
-        }
-    }
-}
-
-fn spawn_flatten_item<O: Clone + SSs>(
-    world: &mut World,
-    parent: Entity,
-    index: usize,
-    inner_signal: impl SignalVec<Item = O> + 'static + Clone,
-) -> (FlattenItem<O>, Vec<O>) {
-    // These are placeholder function calls based on the names
-    let temp_get_state_signal = inner_signal.clone(); // .to_signal().first();
-    let handle = temp_get_state_signal.register(world);
-    let initial_values = poll_signal(world, &handle)
-        .and_then(downcast_any_clone::<Vec<O>>)
-        .unwrap_or_default();
-    handle.cleanup(world);
-
-    let entity = LazyEntity::new();
-    let processor_system = create_flatten_processor(entity.clone(), parent);
-    let processor_handle = inner_signal.for_each(processor_system).register(world);
-
-    entity.set(
-        world
-            .entity_mut(*processor_handle)
-            .insert(FlattenInnerIndex(index))
-            .id(),
-    );
-
-    let item = FlattenItem {
-        processor_handle,
-        values: initial_values.clone(),
-        _marker: PhantomData,
-    };
-
-    (item, initial_values)
-}
-
 /// A node that flattens a `SignalVec` of `SignalVec`s.
 #[derive(Clone)]
 pub struct Flatten<Upstream> {
@@ -1182,7 +888,7 @@ where
     fn register_boxed_signal_vec(self: Box<Self>, world: &mut World) -> SignalHandle {
         self.signal.register(world).into()
     }
-} */
+}
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "tracing")] {
@@ -1531,6 +1237,9 @@ pub trait SignalVecExt: SignalVec {
         S::Item: Clone + Send + Sync,
         F: IntoSystem<In<Self::Item>, S, M> + SSs,
     {
+        #[derive(Component, Deref, DerefMut, Clone, Copy)]
+        struct ItemIndex(usize);
+
         fn spawn_processor<Item: Clone + SSs, S: Signal<Item = Item> + Clone + 'static>(
             world: &mut World,
             output_signal: SignalSystem,
@@ -1893,6 +1602,109 @@ pub trait SignalVecExt: SignalVec {
         S: Signal<Item = bool> + 'static,
         F: IntoSystem<In<Self::Item>, S, M> + SSs,
     {
+        struct FilterSignalItem<T> {
+            signal: SignalHandle,
+            value: T,
+            filtered: bool,
+        }
+
+        #[derive(Component)]
+        struct FilterSignalData<T> {
+            items: Vec<FilterSignalItem<T>>,
+            diffs: Vec<VecDiff<T>>,
+        }
+
+        fn with_filter_signal_data<T: SSs, O>(
+            world: &mut World,
+            entity: Entity,
+            f: impl FnOnce(Mut<FilterSignalData<T>>) -> O,
+        ) -> O {
+            let data = world.get_mut::<FilterSignalData<T>>(entity).unwrap();
+            f(data)
+        }
+
+        fn find_filter_signal_index<T>(filter_signal_items: &[FilterSignalItem<T>], i: usize) -> usize {
+            find_index(filter_signal_items.iter().map(|signal| &signal.filtered), i)
+        }
+
+        #[derive(Component, Deref, DerefMut)]
+        struct FilterSignalIndex(usize);
+
+        fn spawn_filter_signal<T: Clone + SSs>(
+            world: &mut World,
+            index: usize,
+            signal: impl Signal<Item = bool> + 'static,
+            parent: Entity,
+        ) -> (SignalHandle, bool) {
+            let entity = LazyEntity::new();
+            let processor_system = clone!((entity) move |In(filter): In<bool>, world: &mut World| {
+                let self_entity = *entity;
+
+                // The processor might run after its parent has been cleaned up.
+                let Ok(signal_index_comp) = world.query_filtered::<&FilterSignalIndex, Allow<Internal>>().get(world, self_entity) else {
+                    return;
+                };
+                let item_index = signal_index_comp.0;
+                let Ok(mut filter_signal_data) = world.query_filtered::<&mut FilterSignalData<T>, Allow<Internal>>().get_mut(world, parent) else {
+                    return;
+                };
+
+                // This item_index might be stale if other items were removed in the same frame.
+                // Ensure we don't panic.
+                if item_index >= filter_signal_data.items.len() {
+                    return;
+                }
+                let old_filtered_state = filter_signal_data.items[item_index].filtered;
+                if old_filtered_state == filter {
+                    // No change, do nothing.
+                    return;
+                }
+                let diff_to_queue = if filter {
+                    // Item is now INCLUDED. Find its insertion point based on the state _before_ it's
+                    // marked as included.
+                    let new_filtered_index = find_filter_signal_index(&filter_signal_data.items, item_index);
+                    filter_signal_data.items[item_index].filtered = true;
+                    VecDiff::InsertAt {
+                        index: new_filtered_index,
+                        value: filter_signal_data.items[item_index].value.clone(),
+                    }
+                } else {
+                    // Item is now EXCLUDED. Find its removal point based on the state _before_ it's
+                    // marked as excluded.
+                    let old_filtered_index = find_filter_signal_index(&filter_signal_data.items, item_index);
+                    filter_signal_data.items[item_index].filtered = false;
+                    VecDiff::RemoveAt { index: old_filtered_index }
+                };
+                filter_signal_data.diffs.push(diff_to_queue);
+
+                // Poke the main output signal to process its queue immediately.
+                process_signals(world, [parent.into()], Box::new(Vec::<VecDiff<T>>::new()));
+            });
+
+            // Use .map() to attach the processor. The dedupe is still important.
+            let mapped_signal = signal.dedupe().map(processor_system);
+            let handle = mapped_signal.register(world);
+            entity.set(**handle);
+            world.entity_mut(**handle).insert(FilterSignalIndex(index));
+
+            // To get the initial value, we must poll the original signal before the
+            // map/dedupe. The upstream of the `map` node is the `dedupe` node.
+            let dedupe_handle = world.get::<Upstream>(**handle).unwrap().iter().next().cloned().unwrap();
+
+            // The upstream of the `dedupe` node is the original signal.
+            let original_signal_handle = world
+                .get::<Upstream>(*dedupe_handle)
+                .unwrap()
+                .iter()
+                .next()
+                .cloned()
+                .unwrap();
+            let initial_value = poll_signal(world, original_signal_handle)
+                .and_then(downcast_any_clone::<bool>)
+                .expect("filter_signal's inner signal must emit an initial value upon registration");
+            (handle, initial_value)
+        }
+
         let signal = LazySignal::new(move |world: &mut World| {
             let parent_entity = LazyEntity::new();
             let system_id = world.register_system(system);
@@ -2239,6 +2051,13 @@ pub trait SignalVecExt: SignalVec {
         Self: Sized,
         Self::Item: Clone + 'static,
     {
+        #[derive(Component, Default)]
+        struct EnumerateState {
+            key_to_index: HashMap<usize, usize>,
+            ordered_keys: Vec<usize>,
+            next_key: usize,
+        }
+
         let signal = LazySignal::new(move |world: &mut World| {
             let processor_entity_handle = LazyEntity::new();
             let processor_logic = clone!(
@@ -2851,6 +2670,30 @@ pub trait SignalVecExt: SignalVec {
         Self::Item: Clone + SSs,
         F: IntoSystem<In<super::signal::Source<Option<usize>>>, Self::Item, M> + SSs,
     {
+        #[derive(Component)]
+        struct IntersperseState<T> {
+            /// The original, non-interspersed values. We need this to know the length.
+            local_values: Vec<T>,
+            /// Stable keys for the separators. The key at index `i` corresponds to the separator that comes
+            /// _after_ `local_values[i]`.
+            separator_keys: Vec<usize>,
+            /// Maps a separator's stable key to its current logical index (0, 1, 2...).
+            key_to_index: HashMap<usize, usize>,
+            /// A counter to generate new unique, stable keys.
+            next_key: usize,
+        }
+
+        impl<T> Default for IntersperseState<T> {
+            fn default() -> Self {
+                Self {
+                    local_values: Vec::new(),
+                    separator_keys: Vec::new(),
+                    key_to_index: HashMap::new(),
+                    next_key: 0,
+                }
+            }
+        }
+
         let signal = LazySignal::new(move |world: &mut World| {
             // 1. Register the user's factory system once.
             let factory_system_id = world.register_system(separator_system);
@@ -3530,162 +3373,485 @@ pub trait SignalVecExt: SignalVec {
         }
     }
 
-    /* fn flatten(self) -> Flatten<Self>
+    /// Flattens a [`SignalVec`] of [`SignalVec`]s into a single [`SignalVec`].
+    ///
+    /// When the outer [`SignalVec`] adds/removes/moves inner [`SignalVec`]s, or when any inner
+    /// [`SignalVec`] itself changes, the flattened output is updated accordingly.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// let mut world = World::new();
+    ///
+    /// let inner1 = MutableVecBuilder::from([1, 2]).spawn(&mut world);
+    /// let inner2 = MutableVecBuilder::from([3, 4, 5]).spawn(&mut world);
+    ///
+    /// let outer = MutableVecBuilder::from([
+    ///     inner1.signal_vec(),
+    ///     inner2.signal_vec(),
+    /// ]).spawn(&mut world);
+    ///
+    /// let flattened = outer.signal_vec().flatten();
+    /// // flattened outputs `[1, 2, 3, 4, 5]`
+    /// ```
+    fn flatten(self) -> Flatten<Self>
     where
-        Self: Sized, // This should be a trait like SignalVec
+        Self: Sized,
         Self::Item: SignalVec + 'static + Clone,
         <Self::Item as SignalVec>::Item: Clone + SSs,
     {
+        type InnerItem<U> = <<U as SignalVec>::Item as SignalVec>::Item;
+
+        #[derive(Component)]
+        struct FlattenState {
+            /// Each item tracks: (processor handle, current length of that inner signal vec)
+            items: Vec<(SignalHandle, usize)>,
+        }
+
+        /// Component to track which index in the FlattenState.items this processor corresponds to
+        #[derive(Component)]
+        struct FlattenItemIndex(usize);
+
         let signal = LazySignal::new(move |world: &mut World| {
-            let parent_entity = LazyEntity::new();
+            let output_signal_entity = LazyEntity::new();
+
+            // The output signal just drains and emits any queued diffs
+            let output_signal = *SignalBuilder::from_system::<Vec<VecDiff<InnerItem<Self>>>, _, _, _>(
+                clone!((output_signal_entity) move |_: In<()>, world: &mut World| {
+                    if let Some(mut diffs) = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(output_signal_entity.get()) {
+                        if diffs.0.is_empty() {
+                            None
+                        } else {
+                            Some(diffs.0.drain(..).collect())
+                        }
+                    } else {
+                        None
+                    }
+                }),
+            )
+            .register(world);
+            output_signal_entity.set(*output_signal);
+
+            /// Finds all VecReplayTrigger ancestors of a signal
+            fn find_replay_triggers(world: &World, signal: SignalSystem) -> Vec<SignalSystem> {
+                let mut triggers = Vec::new();
+                let mut stack = vec![signal];
+                let mut visited = HashSet::new();
+                while let Some(current) = stack.pop() {
+                    if !visited.insert(current) {
+                        continue;
+                    }
+                    if world.get::<VecReplayTrigger>(*current).is_some() {
+                        triggers.push(current);
+                    }
+                    if let Some(upstream) = world.get::<Upstream>(*current) {
+                        stack.extend(upstream.0.iter().copied());
+                    }
+                }
+                triggers
+            }
+
+            /// Triggers replay on the given signals
+            fn trigger_replays(world: &mut World, triggers: Vec<SignalSystem>) {
+                for signal in triggers {
+                    trigger_replay::<VecReplayTrigger>(world, *signal);
+                }
+            }
+
+            /// Creates a processor for an inner SignalVec that translates its diffs to the flattened output.
+            /// Returns (processor handle, replay triggers to call later).
+            /// NOTE: The caller should add the entry to FlattenState.items and THEN call trigger_replays.
+            fn create_inner_processor<O: Clone + SSs>(
+                world: &mut World,
+                output_signal: SignalSystem,
+                index: usize,
+                inner_signal_vec: impl SignalVec<Item = O> + 'static + Clone,
+            ) -> (SignalHandle, Vec<SignalSystem>) {
+                let processor_entity = LazyEntity::new();
+
+                // Processor that handles diffs from the inner SignalVec
+                let processor_logic = clone!((processor_entity) move |In(diffs): In<Vec<VecDiff<O>>>, world: &mut World| {
+                    let self_entity = processor_entity.get();
+
+                    // Get our current index
+                    let Some(item_index_comp) = world.get::<FlattenItemIndex>(self_entity) else {
+                        return;
+                    };
+                    let item_index = item_index_comp.0;
 
-            let SignalHandle(output_signal) = self
-            .for_each::<Vec<VecDiff<<Self::Item as SignalVec>::Item>>, _, _, _>(
-                clone!((parent_entity) move |In(diffs): In<Vec<VecDiff<Self::Item>>>, world: &mut World| {
-                    let parent = parent_entity.get();
-                    let mut new_diffs = vec![];
+                    // Get the flatten state
+                    let Some(mut state) = world.get_mut::<FlattenState>(*output_signal) else {
+                        return;
+                    };
+
+                    // Bounds check (should not happen if used correctly, but defensive)
+                    if item_index >= state.items.len() {
+                        return;
+                    }
+
+                    // Calculate offset (sum of lengths of all inner vecs before this one)
+                    let offset: usize = state.items[..item_index]
+                        .iter()
+                        .map(|(_, len)| *len)
+                        .sum();
+
+                    let mut out_diffs = Vec::new();
 
                     for diff in diffs {
                         match diff {
-                            VecDiff::Push { value: inner_signal } => {
-                                let index = with_flatten_data::<<Self::Item as SignalVec>::Item, _>(world, parent, |data| data.items.len());
-                                let (item, initial_values) = spawn_flatten_item(world, parent, index, inner_signal);
-                                let offset: usize = with_flatten_data::<<Self::Item as SignalVec>::Item, _>(world, parent, |data| data.items.iter().map(|i| i.values.len()).sum());
-                                with_flatten_data(world, parent, |mut data| data.items.push(item));
-                                for (i, value) in initial_values.into_iter().enumerate() {
-                                    new_diffs.push(VecDiff::InsertAt { index: offset + i, value });
-                                }
-                            }
-                            VecDiff::InsertAt { index, value: inner_signal } => {
-                                let (item, initial_values) = spawn_flatten_item(world, parent, index, inner_signal);
-                                let offset: usize = with_flatten_data::<<Self::Item as SignalVec>::Item, _>(world, parent, |data| data.items[..index].iter().map(|i| i.values.len()).sum());
-                                with_flatten_data(world, parent, |mut data| data.items.insert(index, item));
-                                let signals_to_update = with_flatten_data::<<Self::Item as SignalVec>::Item, _>(world, parent, |data| data.items.iter().map(|i| i.processor_handle.clone()).collect::<Vec<_>>());
-                                for (i, handle) in signals_to_update.into_iter().enumerate() {
-                                    if let Some(mut idx) = world.get_mut::<FlattenInnerIndex>(*handle) {
-                                        idx.0 = i;
-                                    }
+                            VecDiff::Replace { values } => {
+                                // Remove all old values
+                                let old_len = state.items[item_index].1;
+                                for _ in 0..old_len {
+                                    out_diffs.push(VecDiff::RemoveAt { index: offset });
                                 }
-                                for (i, value) in initial_values.into_iter().enumerate() {
-                                    new_diffs.push(VecDiff::InsertAt { index: offset + i, value });
+                                // Insert all new values
+                                for (i, v) in values.iter().enumerate() {
+                                    out_diffs.push(VecDiff::InsertAt {
+                                        index: offset + i,
+                                        value: v.clone(),
+                                    });
                                 }
+                                state.items[item_index].1 = values.len();
                             }
-                            VecDiff::RemoveAt { index } => {
-                                let (item, offset) = with_flatten_data(world, parent, |mut data: Mut<FlattenData<<Self::Item as SignalVec>::Item>>| {
-                                    let offset = data.items[..index].iter().map(|i| i.values.len()).sum();
-                                    (data.items.remove(index), offset)
+                            VecDiff::InsertAt { index, value } => {
+                                state.items[item_index].1 += 1;
+                                out_diffs.push(VecDiff::InsertAt {
+                                    index: offset + index,
+                                    value,
                                 });
-                                item.processor_handle.cleanup(world);
-                                for _ in 0..item.values.len() {
-                                    new_diffs.push(VecDiff::RemoveAt { index: offset });
-                                }
                             }
-                            VecDiff::Pop => {
-                                let (item, offset) = with_flatten_data(world, parent, |mut data: Mut<FlattenData<<Self::Item as SignalVec>::Item>>| {
-                                    let offset = data.items.iter().map(|i| i.values.len()).sum::<usize>().saturating_sub(data.items.last().map_or(0, |i| i.values.len()));
-                                    (data.items.pop().unwrap(), offset)
+                            VecDiff::UpdateAt { index, value } => {
+                                // Length doesn't change for UpdateAt
+                                out_diffs.push(VecDiff::UpdateAt {
+                                    index: offset + index,
+                                    value,
                                 });
-                                item.processor_handle.cleanup(world);
-                                for _ in 0..item.values.len() {
-                                    new_diffs.push(VecDiff::RemoveAt { index: offset });
-                                }
-                            }
-                            VecDiff::Clear => {
-                                let old_items = with_flatten_data(world, parent, |mut data: Mut<FlattenData<<Self::Item as SignalVec>::Item>>| data.items.drain(..).collect::<Vec<_>>());
-                                for item in old_items {
-                                    item.processor_handle.cleanup(world);
-                                }
-                                new_diffs.push(VecDiff::Clear);
-                            }
-                            VecDiff::Replace { values } => {
-                                let old_items = with_flatten_data(world, parent, |mut data: Mut<FlattenData<<Self::Item as SignalVec>::Item>>| data.items.drain(..).collect::<Vec<_>>());
-                                for item in old_items {
-                                    item.processor_handle.cleanup(world);
-                                }
-                                new_diffs.push(VecDiff::Clear);
-                                for (i, inner_signal) in values.into_iter().enumerate() {
-                                    let (item, initial_values) = spawn_flatten_item(world, parent, i, inner_signal);
-                                    with_flatten_data(world, parent, |mut data| data.items.push(item));
-                                    for value in initial_values {
-                                        new_diffs.push(VecDiff::Push { value });
-                                    }
-                                }
                             }
-                            VecDiff::UpdateAt { index, value: inner_signal } => {
-                                let (old_item, offset) = with_flatten_data(world, parent, |mut data: Mut<FlattenData<<Self::Item as SignalVec>::Item>>| {
-                                    let offset = data.items[..index].iter().map(|i| i.values.len()).sum();
-                                    (data.items.remove(index), offset)
+                            VecDiff::RemoveAt { index } => {
+                                state.items[item_index].1 -= 1;
+                                out_diffs.push(VecDiff::RemoveAt {
+                                    index: offset + index,
                                 });
-                                old_item.processor_handle.cleanup(world);
-                                for _ in 0..old_item.values.len() {
-                                    new_diffs.push(VecDiff::RemoveAt { index: offset });
-                                }
-                                let (new_item, initial_values) = spawn_flatten_item(world, parent, index, inner_signal);
-                                with_flatten_data(world, parent, |mut data| data.items.insert(index, new_item));
-                                for (i, value) in initial_values.into_iter().enumerate() {
-                                    new_diffs.push(VecDiff::InsertAt { index: offset + i, value });
-                                }
                             }
                             VecDiff::Move { old_index, new_index } => {
-                                let (old_offset, moved_item, signals_to_update) = with_flatten_data(world, parent, |mut data: Mut<FlattenData<<Self::Item as SignalVec>::Item>>| {
-                                    let old_offset = data.items[..old_index].iter().map(|i| i.values.len()).sum();
-                                    let moved_item = data.items.remove(old_index);
-                                    data.items.insert(new_index, moved_item);
-                                    let signals_to_update = data.items.iter().map(|i| i.processor_handle.clone()).collect::<Vec<_>>();
-                                    (old_offset, data.items[new_index].clone(), signals_to_update)
+                                // Length doesn't change for Move
+                                out_diffs.push(VecDiff::Move {
+                                    old_index: offset + old_index,
+                                    new_index: offset + new_index,
                                 });
-
-                                for (i, handle) in signals_to_update.into_iter().enumerate() {
-                                    if let Some(mut fi_index) = world.get_mut::<FlattenInnerIndex>(*handle) {
-                                        fi_index.0 = i;
-                                    }
-                                }
-                                for _ in 0..moved_item.values.len() {
-                                    new_diffs.push(VecDiff::RemoveAt { index: old_offset });
+                            }
+                            VecDiff::Push { value } => {
+                                let insert_index = offset + state.items[item_index].1;
+                                state.items[item_index].1 += 1;
+                                out_diffs.push(VecDiff::InsertAt {
+                                    index: insert_index,
+                                    value,
+                                });
+                            }
+                            VecDiff::Pop => {
+                                if state.items[item_index].1 > 0 {
+                                    state.items[item_index].1 -= 1;
+                                    out_diffs.push(VecDiff::RemoveAt {
+                                        index: offset + state.items[item_index].1,
+                                    });
                                 }
-                                let new_offset: usize = with_flatten_data::<<Self::Item as SignalVec>::Item, _>(world, parent, |data| data.items[..new_index].iter().map(|i| i.values.len()).sum());
-                                for (i, value) in moved_item.values.into_iter().enumerate() {
-                                    new_diffs.push(VecDiff::InsertAt { index: new_offset + i, value });
+                            }
+                            VecDiff::Clear => {
+                                let old_len = state.items[item_index].1;
+                                state.items[item_index].1 = 0;
+                                for _ in 0..old_len {
+                                    out_diffs.push(VecDiff::RemoveAt { index: offset });
                                 }
                             }
                         }
                     }
 
-                    let queued_diffs = with_flatten_data(world, parent, |mut data: Mut<FlattenData<<Self::Item as SignalVec>::Item>>| data.diffs.drain(..).collect::<Vec<_>>());
-                    new_diffs.extend(queued_diffs);
-
-                    if new_diffs.is_empty() {
-                        None
-                    } else {
-                        Some(new_diffs)
+                    // Queue the translated diffs
+                    if !out_diffs.is_empty() {
+                        if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<O>>(*output_signal) {
+                            queue.0.extend(out_diffs);
+                        }
+                        process_signals(world, [output_signal], Box::new(()));
                     }
-                }),
-            )
-            .register(world);
+                });
 
-            parent_entity.set(output_signal);
+                // Register the processor
+                let processor_handle = inner_signal_vec.for_each(processor_logic).register(world);
+                processor_entity.set(**processor_handle);
+                world.entity_mut(**processor_handle).insert(FlattenItemIndex(index));
 
-            let SignalHandle(flusher) = SignalBuilder::from_entity(output_signal)
-                .map::<Vec<VecDiff<<Self::Item as SignalVec>::Item>>, _, _, _>(
-                    move |In(_), data: Query<&FlattenData<<Self::Item as SignalVec>::Item>>| {
-                        if let Ok(data) = data.get(parent_entity.get()) {
-                            if !data.diffs.is_empty() {
-                                return Some(vec![]);
-                            }
-                        }
-                        None
-                    },
-                )
-                .register(world);
+                // Find replay triggers but don't trigger them yet
+                let replay_triggers = find_replay_triggers(world, (**processor_handle).into());
 
-            pipe_signal(world, flusher, output_signal);
+                (processor_handle, replay_triggers)
+            }
 
-            world
-                .entity_mut(output_signal)
-                .insert(FlattenData::<<Self::Item as SignalVec>::Item> {
-                    items: vec![],
-                    diffs: vec![],
-                });
+            // Main manager that handles outer SignalVec diffs
+            let manager_logic = clone!((output_signal_entity) move |In(diffs): In<Vec<VecDiff<Self::Item>>>, world: &mut World| {
+                let output_signal: SignalSystem = output_signal_entity.get().into();
+                let mut out_diffs: Vec<VecDiff<InnerItem<Self>>> = Vec::new();
+
+                for diff in diffs {
+                    match diff {
+                        VecDiff::Replace { values } => {
+                            // Clean up all old processors
+                            let old_items = {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                state.items.drain(..).collect::<Vec<_>>()
+                            };
+                            let had_old_items = !old_items.is_empty();
+                            for (handle, _) in old_items {
+                                handle.cleanup(world);
+                            }
+                            // Only emit Clear if there were old items
+                            // Note: The inner processors will emit InsertAt diffs for their initial values,
+                            // so we need Clear to come BEFORE those. We'll queue it directly now.
+                            if had_old_items {
+                                if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal) {
+                                    queue.0.push(VecDiff::Clear);
+                                }
+                            }
+
+                            // Create processors and collect their replay triggers
+                            let mut all_triggers = Vec::new();
+                            for (i, inner_signal_vec) in values.into_iter().enumerate() {
+                                let (handle, triggers) = create_inner_processor(world, output_signal, i, inner_signal_vec);
+                                // Add entry with real handle
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                state.items.push((handle, 0));
+                                all_triggers.extend(triggers);
+                            }
+                            // Now trigger all replays (entries exist)
+                            trigger_replays(world, all_triggers);
+                        }
+                        VecDiff::InsertAt { index, value: inner_signal_vec } => {
+                            // Update indices for all items after the insertion point FIRST
+                            {
+                                let handles_to_update: Vec<_> = {
+                                    let state = world.get::<FlattenState>(*output_signal).unwrap();
+                                    state.items
+                                        .iter()
+                                        .enumerate()
+                                        .skip(index)
+                                        .map(|(i, (h, _))| (**h, i + 1))
+                                        .collect()
+                                };
+                                for (handle_entity, new_index) in handles_to_update {
+                                    if let Some(mut idx) = world.get_mut::<FlattenItemIndex>(*handle_entity) {
+                                        idx.0 = new_index;
+                                    }
+                                }
+                            }
+
+                            // Create processor
+                            let (handle, triggers) = create_inner_processor(world, output_signal, index, inner_signal_vec);
+
+                            // Insert entry with real handle
+                            {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                state.items.insert(index, (handle, 0));
+                            }
+
+                            // Now trigger replays (entry exists)
+                            trigger_replays(world, triggers);
+                        }
+                        VecDiff::UpdateAt { index, value: inner_signal_vec } => {
+                            // Remove old processor and its values
+                            let (old_handle, old_len, offset) = {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                let offset: usize = state.items[..index].iter().map(|(_, len)| *len).sum();
+                                let (old_handle, old_len) = state.items.remove(index);
+                                (old_handle, old_len, offset)
+                            };
+                            old_handle.cleanup(world);
+
+                            // Emit RemoveAt for old values IMMEDIATELY (before creating new processor)
+                            // because trigger_replays will emit InsertAt diffs
+                            if old_len > 0 {
+                                let mut remove_diffs = Vec::new();
+                                for _ in 0..old_len {
+                                    remove_diffs.push(VecDiff::RemoveAt { index: offset });
+                                }
+                                if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal) {
+                                    queue.0.extend(remove_diffs);
+                                }
+                            }
+
+                            // Create new processor
+                            let (handle, triggers) = create_inner_processor(world, output_signal, index, inner_signal_vec);
+
+                            // Insert entry with real handle
+                            {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                state.items.insert(index, (handle, 0));
+                            }
+
+                            // Now trigger replays (entry exists)
+                            trigger_replays(world, triggers);
+                        }
+                        VecDiff::RemoveAt { index } => {
+                            let (handle, old_len, offset) = {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                let offset: usize = state.items[..index].iter().map(|(_, len)| *len).sum();
+                                let (handle, len) = state.items.remove(index);
+                                (handle, len, offset)
+                            };
+                            handle.cleanup(world);
+
+                            // Update indices for items after the removal
+                            {
+                                let handles_to_update: Vec<_> = {
+                                    let state = world.get::<FlattenState>(*output_signal).unwrap();
+                                    state.items
+                                        .iter()
+                                        .enumerate()
+                                        .skip(index)
+                                        .map(|(i, (h, _))| (**h, i))
+                                        .collect()
+                                };
+                                for (handle_entity, new_index) in handles_to_update {
+                                    if let Some(mut idx) = world.get_mut::<FlattenItemIndex>(*handle_entity) {
+                                        idx.0 = new_index;
+                                    }
+                                }
+                            }
+
+                            for _ in 0..old_len {
+                                out_diffs.push(VecDiff::RemoveAt { index: offset });
+                            }
+                        }
+                        VecDiff::Move { old_index, new_index } => {
+                            let (old_offset, moved_len) = {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                let old_offset: usize = state.items[..old_index].iter().map(|(_, len)| *len).sum();
+                                let item = state.items.remove(old_index);
+                                let moved_len = item.1;
+                                state.items.insert(new_index, item);
+                                (old_offset, moved_len)
+                            };
+
+                            // Update indices for all affected items
+                            {
+                                let handles_to_update: Vec<_> = {
+                                    let state = world.get::<FlattenState>(*output_signal).unwrap();
+                                    let start = old_index.min(new_index);
+                                    let end = old_index.max(new_index) + 1;
+                                    state.items
+                                        .iter()
+                                        .enumerate()
+                                        .skip(start)
+                                        .take(end - start)
+                                        .map(|(i, (h, _))| (**h, i))
+                                        .collect()
+                                };
+                                for (handle_entity, new_idx) in handles_to_update {
+                                    if let Some(mut idx) = world.get_mut::<FlattenItemIndex>(*handle_entity) {
+                                        idx.0 = new_idx;
+                                    }
+                                }
+                            }
+
+                            // Calculate the new offset after the move
+                            let new_offset: usize = {
+                                let state = world.get::<FlattenState>(*output_signal).unwrap();
+                                state.items[..new_index].iter().map(|(_, len)| *len).sum()
+                            };
+
+                            // Emit Move diffs for each element in the block
+                            // We need to move elements one by one from old position to new position
+                            if old_offset < new_offset {
+                                // Moving forward: move from end to start to avoid overwriting
+                                for i in (0..moved_len).rev() {
+                                    out_diffs.push(VecDiff::Move {
+                                        old_index: old_offset + i,
+                                        new_index: new_offset + i,
+                                    });
+                                }
+                            } else if old_offset > new_offset {
+                                // Moving backward: move from start to end
+                                for i in 0..moved_len {
+                                    out_diffs.push(VecDiff::Move {
+                                        old_index: old_offset + i,
+                                        new_index: new_offset + i,
+                                    });
+                                }
+                            }
+                            // If offsets are equal, no moves needed
+                        }
+                        VecDiff::Push { value: inner_signal_vec } => {
+                            let index = {
+                                let state = world.get::<FlattenState>(*output_signal).unwrap();
+                                state.items.len()
+                            };
+
+                            // Create processor
+                            let (handle, triggers) = create_inner_processor(world, output_signal, index, inner_signal_vec);
+
+                            // Push entry with real handle
+                            {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                state.items.push((handle, 0));
+                            }
+
+                            // Now trigger replays (entry exists)
+                            trigger_replays(world, triggers);
+                        }
+                        VecDiff::Pop => {
+                            let (handle, old_len, offset) = {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                if let Some((handle, len)) = state.items.pop() {
+                                    let offset: usize = state.items.iter().map(|(_, len)| *len).sum();
+                                    (Some(handle), len, offset)
+                                } else {
+                                    (None, 0, 0)
+                                }
+                            };
+
+                            if let Some(handle) = handle {
+                                handle.cleanup(world);
+                            }
+                            for _ in 0..old_len {
+                                out_diffs.push(VecDiff::RemoveAt { index: offset });
+                            }
+                        }
+                        VecDiff::Clear => {
+                            let old_items = {
+                                let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
+                                state.items.drain(..).collect::<Vec<_>>()
+                            };
+                            for (handle, _) in old_items {
+                                handle.cleanup(world);
+                            }
+                            out_diffs.push(VecDiff::Clear);
+                        }
+                    }
+                }
+
+                // Queue the diffs
+                if !out_diffs.is_empty() {
+                    if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal) {
+                        queue.0.extend(out_diffs);
+                    }
+                    process_signals(world, [output_signal], Box::new(()));
+                }
+            });
+
+            let manager_handle = self.for_each(manager_logic).register(world);
+
+            // Pipe manager to output_signal so output_signal processes AFTER manager fills the queue
+            pipe_signal(world, *manager_handle, output_signal);
+
+            world
+                .entity_mut(*output_signal)
+                .insert((
+                    FlattenState { items: vec![] },
+                    QueuedVecDiffs::<InnerItem<Self>>(vec![]),
+                ))
+                .insert(SignalHandles::from([manager_handle]));
 
             output_signal
         });
@@ -3694,7 +3860,7 @@ pub trait SignalVecExt: SignalVec {
             signal,
             _marker: PhantomData,
         }
-    } */
+    }
 
     #[cfg(feature = "tracing")]
     #[track_caller]
@@ -4005,10 +4171,9 @@ impl<T> MutableVec<T> {
             let was_initially_empty = self_.read(&*world).is_empty();
 
             let replay_entity = LazyEntity::new();
-            let is_first_replay = Arc::new(AtomicBool::new(true));
-            let replay_system = clone!((self_, replay_entity, is_first_replay) move |In(upstream_diffs): In<Vec<VecDiff<T>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_vec_datas: Query<&MutableVecData<T>>| {
+            let replay_system = clone!((self_, replay_entity) move |In(upstream_diffs): In<Vec<VecDiff<T>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_vec_datas: Query<&MutableVecData<T>>, mut has_replayed: Local<bool>| {
                 if replay_onces.contains(*replay_entity) {
-                    let first_replay = is_first_replay.swap(false, AtomicOrdering::SeqCst);
+                    let first_replay = !core::mem::replace(&mut *has_replayed, true);
                     if first_replay && was_initially_empty {
                         // Initial replay with empty vec - just forward upstream diffs
                         if upstream_diffs.is_empty() {
@@ -7589,138 +7754,578 @@ pub(crate) mod tests {
         cleanup(true)
     }
 
-    /* #[test]
+    #[test]
     fn test_flatten() {
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<u32>>();
-
-        // --- Setup ---
-        // Create the inner vectors that will be the items of our outer vector.
-        let vec_a = MutableVec::from([10u32, 11]);
-        let vec_b = MutableVec::from([20u32]);
-        let vec_c = MutableVec::from([]); // Start with an empty inner vec
-
-        // Create the outer vector, which holds SignalVecs.
-        let source_of_vecs = MutableVec::from([vec_a.signal_vec(), vec_b.signal_vec(), vec_c.signal_vec()]);
-
-        // The signal chain under test.
-        let flattened_signal = source_of_vecs.signal_vec().flatten();
-
-        let handle = flattened_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
-
-        // --- 1. Initial State ---
-        // The first update should replay the initial state of all inner vectors.
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace {
-                values: vec![10, 11, 20]
-            },
-            "Initial state should be a Replace with combined contents."
-        );
+        {
+            // A comprehensive test for `SignalVecExt::flatten`. This tests flattening a
+            // SignalVec of SignalVecs into a single SignalVec, covering:
+            // - Initial state
+            // - Inner vec changes (push, pop, update, etc.)
+            // - Outer vec changes (push, pop, remove, move, clear, replace, update)
+            // - Cleanup verification (removed inner vecs should be ignored)
 
-        let mut current_state = vec![10, 11, 20];
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
 
-        // --- 2. Inner Vec Change: Push to `vec_a` ---
-        // A push to the _first_ inner vector should insert at the correct global index.
-        vec_a.write().push(12);
-        app.update();
+            // --- Setup ---
+            // Create the inner vectors that will be the items of our outer vector.
+            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
+            let vec_c = MutableVecBuilder::<u32>::from([]).spawn(app.world_mut()); // Start with an empty inner vec
+
+            // Create the outer vector, which holds SignalVecs.
+            // No need for boxed_clone() since all inner vecs are the same concrete type (Source<u32>)
+            let source_of_vecs = MutableVecBuilder::from([
+                vec_a.signal_vec(),
+                vec_b.signal_vec(),
+                vec_c.signal_vec(),
+            ])
+            .spawn(app.world_mut());
 
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Push to inner vec_a should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt { index: 2, value: 12 },
-            "Should insert at index 2 (end of vec_a's block)."
-        );
-        apply_diffs(&mut current_state, diffs);
-        assert_eq!(current_state, vec![10, 11, 12, 20]);
-
-        // --- 3. Inner Vec Change: Push to `vec_b` ---
-        // A push to the _second_ inner vector should insert at an offset index.
-        vec_b.write().push(21);
-        app.update();
-
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Push to inner vec_b should produce one diff.");
-        // Global index = len(vec_a) + new_index_in_b = 3 + 1 = 4
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt { index: 4, value: 21 },
-            "Should insert at index 4 (end of vec_b's block)."
-        );
-        apply_diffs(&mut current_state, diffs);
-        assert_eq!(current_state, vec![10, 11, 12, 20, 21]);
-
-        // --- 4. Outer Vec Change: Remove `vec_b` ---
-        // Removing an inner vector should remove its entire block of items.
-        source_of_vecs.write().remove(1); // Removes vec_b
-        app.update();
-
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        // The implementation should produce two RemoveAt diffs for vec_b's two items.
-        assert_eq!(diffs.len(), 2, "Removing vec_b should produce 2 diffs.");
-        apply_diffs(&mut current_state, diffs);
-        // The final state should no longer contain 20 or 21.
-        assert_eq!(
-            current_state,
-            vec![10, 11, 12],
-            "State after removing vec_b is incorrect."
-        );
-        // Note: vec_c is now at index 1 in the outer vec.
-
-        // --- 5. Cleanup Verification ---
-        // Updates to the removed `vec_b` should now be ignored.
-        vec_b.write().push(99);
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert!(diffs.is_empty(), "Should ignore diffs from the removed vec_b.");
-
-        // --- 6. Outer Vec Change: Push a new vector ---
-        let vec_d = MutableVec::from([40u32, 41]);
-        source_of_vecs.write().push(vec_d.signal_vec());
-        app.update();
-
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        // Pushing a new inner vector should add its initial items to the end.
-        assert_eq!(diffs.len(), 2, "Pushing new vec_d should produce 2 diffs.");
-        apply_diffs(&mut current_state, diffs);
-        assert_eq!(
-            current_state,
-            vec![10, 11, 12, 40, 41],
-            "State after pushing vec_d is incorrect."
-        );
+            // The signal chain under test.
+            let flattened_signal = source_of_vecs.signal_vec().flatten();
 
-        // --- 7. Outer Vec Change: Move ---
-        // Current outer vec: [vec_a, vec_c, vec_d].
-        // Current state: [10, 11, 12, (empty), 40, 41].
-        // Move vec_d (index 2) to the front (index 0).
-        source_of_vecs.write().move_item(2, 0);
-        app.update();
-
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        apply_diffs(&mut current_state, diffs);
-        assert_eq!(
-            current_state,
-            vec![40, 41, 10, 11, 12],
-            "State after moving vec_d to front is incorrect."
-        );
+            let handle = flattened_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
 
-        // --- 8. Outer Vec Change: Clear ---
-        // Clearing the outer vector should remove all items.
-        source_of_vecs.write().clear();
-        app.update();
+            // --- 1. Initial State ---
+            // The first update should replay the initial state of all inner vectors.
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            // Initial state should be Clear + Push for each item
+            let mut current_state: Vec<u32> = vec![];
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![10, 11, 20],
+                "Initial state should contain combined contents of all inner vecs."
+            );
+
+            // --- 2. Inner Vec Change: Push to `vec_a` ---
+            // A push to the _first_ inner vector should insert at the correct global index.
+            vec_a.write(app.world_mut()).push(12);
+            app.update();
 
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Clear on outer vec should produce one diff.");
-        assert_eq!(diffs[0], VecDiff::Clear, "Expected a Clear diff.");
-        apply_diffs(&mut current_state, diffs);
-        assert!(current_state.is_empty(), "Final state should be empty after clear.");
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push to inner vec_a should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt { index: 2, value: 12 },
+                "Should insert at index 2 (end of vec_a's block)."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 11, 12, 20]);
 
-        handle.cleanup(app.world_mut());
-    } */
-}
+            // --- 3. Inner Vec Change: Push to `vec_b` ---
+            // A push to the _second_ inner vector should insert at an offset index.
+            vec_b.write(app.world_mut()).push(21);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push to inner vec_b should produce one diff.");
+            // Global index = len(vec_a) + new_index_in_b = 3 + 1 = 4
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt { index: 4, value: 21 },
+                "Should insert at index 4 (end of vec_b's block)."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 11, 12, 20, 21]);
+
+            // --- 4. Inner Vec Change: UpdateAt on vec_a ---
+            vec_a.write(app.world_mut()).set(1, 111);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "UpdateAt on vec_a should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt { index: 1, value: 111 },
+                "Should update at correct global index."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 111, 12, 20, 21]);
+
+            // --- 5. Inner Vec Change: RemoveAt on vec_a ---
+            vec_a.write(app.world_mut()).remove(0);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "RemoveAt on vec_a should produce one diff.");
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![111, 12, 20, 21]);
+
+            // --- 6. Inner Vec Change: Pop on vec_b ---
+            vec_b.write(app.world_mut()).pop();
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Pop on vec_b should produce one diff.");
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 3 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![111, 12, 20]);
+
+            // --- 7. Outer Vec Change: Remove `vec_b` ---
+            // Removing an inner vector should remove its entire block of items.
+            source_of_vecs.write(app.world_mut()).remove(1); // Removes vec_b
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            // The implementation should produce one RemoveAt diff for vec_b's remaining item.
+            assert_eq!(diffs.len(), 1, "Removing vec_b should produce 1 diff.");
+            apply_diffs(&mut current_state, diffs);
+            // The final state should no longer contain 20.
+            assert_eq!(
+                current_state,
+                vec![111, 12],
+                "State after removing vec_b is incorrect."
+            );
+            // Note: vec_c is now at index 1 in the outer vec.
+
+            // --- 8. Cleanup Verification ---
+            // Updates to the removed `vec_b` should now be ignored.
+            vec_b.write(app.world_mut()).push(99);
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert!(diffs.is_empty(), "Should ignore diffs from the removed vec_b.");
+
+            // --- 9. Outer Vec Change: Push a new vector ---
+            let vec_d = MutableVecBuilder::from([40u32, 41]).spawn(app.world_mut());
+            source_of_vecs.write(app.world_mut()).push(vec_d.signal_vec());
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            // Pushing a new inner vector should add its initial items to the end.
+            assert_eq!(diffs.len(), 2, "Pushing new vec_d should produce 2 diffs.");
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![111, 12, 40, 41],
+                "State after pushing vec_d is incorrect."
+            );
+
+            // --- 10. Inner Vec Change: Push to empty vec_c ---
+            // vec_c is currently at outer index 1 (between vec_a and vec_d)
+            vec_c.write(app.world_mut()).push(30);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push to empty vec_c should produce one diff.");
+            // Global index = len(vec_a) = 2
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt { index: 2, value: 30 },
+                "Should insert at correct position between vec_a and vec_d."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![111, 12, 30, 40, 41]);
+
+            // --- 11. Outer Vec Change: Move ---
+            // Current outer vec: [vec_a, vec_c, vec_d].
+            // Current state: [111, 12, 30, 40, 41].
+            // Move vec_d (index 2) to the front (index 0).
+            source_of_vecs.write(app.world_mut()).move_item(2, 0);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![40, 41, 111, 12, 30],
+                "State after moving vec_d to front is incorrect."
+            );
+
+            // --- 12. Outer Vec Change: UpdateAt (replace vec_c with a new vec) ---
+            let vec_e = MutableVecBuilder::from([50u32, 51, 52]).spawn(app.world_mut());
+            source_of_vecs.write(app.world_mut()).set(2, vec_e.signal_vec()); // Replace vec_c
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            // vec_c had [30], vec_e has [50, 51, 52]
+            assert_eq!(
+                current_state,
+                vec![40, 41, 111, 12, 50, 51, 52],
+                "State after UpdateAt on outer vec is incorrect."
+            );
+
+            // --- 13. Outer Vec Change: Pop ---
+            source_of_vecs.write(app.world_mut()).pop();
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![40, 41, 111, 12],
+                "State after Pop on outer vec is incorrect."
+            );
+
+            // --- 14. Outer Vec Change: Clear ---
+            // Clearing the outer vector should remove all items.
+            source_of_vecs.write(app.world_mut()).clear();
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Clear on outer vec should produce one diff.");
+            assert_eq!(diffs[0], VecDiff::Clear, "Expected a Clear diff.");
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty(), "Final state should be empty after clear.");
+
+            // --- 15. Outer Vec Change: Replace (re-populate after clear) ---
+            let vec_f = MutableVecBuilder::from([60u32]).spawn(app.world_mut());
+            let vec_g = MutableVecBuilder::from([70u32, 71]).spawn(app.world_mut());
+            source_of_vecs.write(app.world_mut()).replace(vec![
+                vec_f.signal_vec(),
+                vec_g.signal_vec(),
+            ]);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![60, 70, 71],
+                "State after Replace on outer vec is incorrect."
+            );
+
+            // --- 16. Inner Vec Change: Move within vec_g ---
+            vec_g.write(app.world_mut()).move_item(0, 1);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Move within vec_g should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Move {
+                    old_index: 1,
+                    new_index: 2
+                },
+                "Move should be translated to correct global indices."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![60, 71, 70]);
+
+            // --- 17. Inner Vec Change: Clear on vec_g ---
+            vec_g.write(app.world_mut()).clear();
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            // Clear should produce RemoveAt diffs for each item
+            assert_eq!(diffs.len(), 2, "Clear on vec_g should produce 2 diffs.");
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![60]);
+
+            // --- 18. Inner Vec Change: Replace on vec_f ---
+            vec_f.write(app.world_mut()).replace(vec![61, 62, 63]);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![61, 62, 63],
+                "State after Replace on vec_f is incorrect."
+            );
+
+            // --- Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
+
+        // Additional edge case tests
+        {
+            // --- 19. InsertAt on outer vec (insert in middle) ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
+
+            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVecBuilder::from([30u32, 31]).spawn(app.world_mut());
+
+            let source = MutableVecBuilder::from([
+                vec_a.signal_vec(),
+                vec_b.signal_vec(),
+            ])
+            .spawn(app.world_mut());
+
+            let handle = source
+                .signal_vec()
+                .flatten()
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            let mut current_state: Vec<u32> = vec![];
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 11, 30, 31], "Initial state");
+
+            // Insert a new inner vec in the middle
+            let vec_mid = MutableVecBuilder::from([20u32, 21, 22]).spawn(app.world_mut());
+            source.write(app.world_mut()).insert(1, vec_mid.signal_vec());
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![10, 11, 20, 21, 22, 30, 31],
+                "InsertAt on outer vec should insert items at correct position."
+            );
+
+            // Verify that updates to the inserted vec work correctly
+            vec_mid.write(app.world_mut()).push(23);
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![10, 11, 20, 21, 22, 23, 30, 31],
+                "Push to inserted vec should work correctly."
+            );
+
+            // Verify that the vec after the insertion still has correct indices
+            vec_b.write(app.world_mut()).push(32);
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![10, 11, 20, 21, 22, 23, 30, 31, 32],
+                "Push to vec after insertion should work correctly."
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
+        {
+            // --- 20. Multiple simultaneous inner vec changes ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
+
+            let vec_a = MutableVecBuilder::from([10u32]).spawn(app.world_mut());
+            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
+
+            let source = MutableVecBuilder::from([
+                vec_a.signal_vec(),
+                vec_b.signal_vec(),
+            ])
+            .spawn(app.world_mut());
+
+            let handle = source
+                .signal_vec()
+                .flatten()
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            let mut current_state: Vec<u32> = vec![];
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 20], "Initial state");
+
+            // Make changes to both inner vecs before update
+            vec_a.write(app.world_mut()).push(11);
+            vec_b.write(app.world_mut()).push(21);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![10, 11, 20, 21],
+                "Multiple simultaneous changes should all be processed."
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
+        {
+            // --- 21. Empty outer vec initially ---
+            // Note: When starting with an empty outer vec, we need to specify the type explicitly.
+            // Using Source<u32> directly avoids boxing.
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
+
+            let source = MutableVecBuilder::<Source<u32>>::from([]).spawn(app.world_mut());
+
+            let handle = source
+                .signal_vec()
+                .flatten()
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            let mut current_state: Vec<u32> = vec![];
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty(), "Initial state should be empty");
+
+            // Push first inner vec
+            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
+            source.write(app.world_mut()).push(vec_a.signal_vec());
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 11], "Push to empty outer vec");
+
+            // Push second inner vec
+            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
+            source.write(app.world_mut()).push(vec_b.signal_vec());
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 11, 20], "Second push to outer vec");
+
+            handle.cleanup(app.world_mut());
+        }
+
+        {
+            // --- 22. Move forward on outer vec (index 0 -> 2) ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
+
+            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
+            let vec_c = MutableVecBuilder::from([30u32, 31, 32]).spawn(app.world_mut());
+
+            let source = MutableVecBuilder::from([
+                vec_a.signal_vec(),
+                vec_b.signal_vec(),
+                vec_c.signal_vec(),
+            ])
+            .spawn(app.world_mut());
+
+            let handle = source
+                .signal_vec()
+                .flatten()
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            let mut current_state: Vec<u32> = vec![];
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 11, 20, 30, 31, 32], "Initial state");
+
+            // Move vec_a (index 0) to the end (index 2)
+            source.write(app.world_mut()).move_item(0, 2);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![20, 30, 31, 32, 10, 11],
+                "Move forward on outer vec should work correctly."
+            );
+
+            // Verify updates still work after move
+            vec_a.write(app.world_mut()).push(12);
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![20, 30, 31, 32, 10, 11, 12],
+                "Push to moved vec should work correctly."
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
+        {
+            // --- 23. Moving an empty inner vec ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
+
+            let vec_a = MutableVecBuilder::from([10u32]).spawn(app.world_mut());
+            let vec_empty = MutableVecBuilder::<u32>::from([]).spawn(app.world_mut());
+            let vec_c = MutableVecBuilder::from([30u32]).spawn(app.world_mut());
+
+            let source = MutableVecBuilder::from([
+                vec_a.signal_vec(),
+                vec_empty.signal_vec(),
+                vec_c.signal_vec(),
+            ])
+            .spawn(app.world_mut());
+
+            let handle = source
+                .signal_vec()
+                .flatten()
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            let mut current_state: Vec<u32> = vec![];
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 30], "Initial state with empty inner vec");
+
+            // Move the empty vec to the end
+            source.write(app.world_mut()).move_item(1, 2);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            // Moving empty vec should produce no move diffs
+            assert!(diffs.is_empty(), "Moving empty inner vec should produce no diffs");
+            assert_eq!(current_state, vec![10, 30], "State unchanged after moving empty vec");
+
+            // Verify the empty vec now works at its new position
+            vec_empty.write(app.world_mut()).push(20);
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![10, 30, 20],
+                "Push to moved empty vec should insert at end."
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
+        {
+            // --- 24. Moving a non-empty inner vec vs empty (verify Move diffs emitted) ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
+
+            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
+
+            let source = MutableVecBuilder::from([
+                vec_a.signal_vec(),
+                vec_b.signal_vec(),
+            ])
+            .spawn(app.world_mut());
+
+            let handle = source
+                .signal_vec()
+                .flatten()
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            let mut current_state: Vec<u32> = vec![];
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 11, 20], "Initial state");
+
+            // Move vec_a (2 items) to after vec_b
+            source.write(app.world_mut()).move_item(0, 1);
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            // Should emit 2 Move diffs (one for each item in vec_a)
+            assert_eq!(diffs.len(), 2, "Moving vec with 2 items should produce 2 Move diffs");
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![20, 10, 11], "State after move");
+
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true);
+    }}
\ No newline at end of file

From aca97cfe54c6ec06adca0cfe166d9385b0d32bac Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Fri, 16 Jan 2026 03:29:33 -0800
Subject: [PATCH 09/15] topological eval

---
 src/graph.rs  | 757 ++++++++++++++++++++++++++++++++++++++++++++------
 src/lib.rs    |   1 +
 src/signal.rs | 196 ++++++++++---
 3 files changed, 839 insertions(+), 115 deletions(-)

diff --git a/src/graph.rs b/src/graph.rs
index 64522db..fc4b733 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -1,5 +1,6 @@
 //! Signal graph management and runtime.
 use super::utils::SSs;
+use alloc::collections::VecDeque;
 use bevy_derive::Deref;
 use bevy_ecs::{
     entity_disabling::Internal,
@@ -134,6 +135,7 @@ pub(crate) fn pipe_signal(world: &mut World, source: SignalSystem, target: Signa
             downstream.insert(Upstream(HashSet::from([source])));
         }
     }
+    world.resource_mut::<SignalGraphState>().edge_change_seeds.insert(target);
 }
 
 #[derive(Component, Clone)]
@@ -198,47 +200,458 @@ clone_trait_object!(AnyClone);
 
 impl<T: Clone + 'static> AnyClone for T {}
 
+
+/// Tracks signal graph topology for level-based processing.
+#[derive(Resource, Default)]
+pub(crate) struct SignalGraphState {
+    /// Cached level for each signal (max distance from any root).
+    levels: HashMap<SignalSystem, u32>,
+    /// Signals grouped by level for efficient iteration.
+    by_level: Vec<Vec<SignalSystem>>,
+    /// Signals that seed level recomputation after edge changes.
+    edge_change_seeds: HashSet<SignalSystem>,
+    /// Signals queued for removal while the graph is being processed.
+    deferred_removals: HashSet<SignalSystem>,
+    /// Whether the signal graph is currently being processed.
+    is_processing: bool,
+}
+
+// Fan out a signal output to downstream input queues. When there is exactly one downstream, move the value without cloning.
+fn enqueue_inputs(
+    world: &World,
+    inputs: &mut HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>>,
+    signal: SignalSystem,
+    value: Box<dyn AnyClone>,
+) {
+    let downstreams = get_downstreams(world, signal);
+    if downstreams.is_empty() {
+        return;
+    }
+
+    if downstreams.len() == 1 {
+        // avoid cloning if there's only a single downstream
+        inputs
+            .entry(downstreams[0])
+            .or_default()
+            .push_back(value);
+        return;
+    }
+
+    if let Some((last, rest)) = downstreams.split_last() {
+        for downstream in rest {
+            inputs
+                .entry(*downstream)
+                .or_default()
+                .push_back(value.clone());
+        }
+        inputs.entry(*last).or_default().push_back(value);
+    }
+}
+
+fn get_upstreams(world: &World, signal: SignalSystem) -> Vec<SignalSystem> {
+    world
+        .get::<Upstream>(*signal)
+        .map(|u| u.0.iter().copied().collect())
+        .unwrap_or_default()
+}
+
+fn get_downstreams(world: &World, signal: SignalSystem) -> Vec<SignalSystem> {
+    world
+        .get::<Downstream>(*signal)
+        .map(|d| d.0.iter().copied().collect())
+        .unwrap_or_default()
+}
+
+fn insert_sorted_by_index(bucket: &mut Vec<SignalSystem>, signal: SignalSystem) {
+    if bucket.iter().any(|s| *s == signal) {
+        return;
+    }
+    let key = signal.index();
+    let index = bucket
+        .binary_search_by_key(&key, |s| s.index())
+        .unwrap_or_else(|i| i);
+    bucket.insert(index, signal);
+}
+
+// Computes a per-call, local topological ordering of signals reachable downstream
+// from `seeds`. This intentionally does NOT use `SignalGraphState` because it only
+// needs a lightweight traversal for the provided subset and should not mutate or
+// depend on the global cached topology.
+fn downstream_levels_from_seeds(
+    world: &World,
+    seeds: &[SignalSystem],
+) -> Vec<Vec<SignalSystem>> {
+    let mut levels: HashMap<SignalSystem, u32> = HashMap::new();
+    let mut by_level: Vec<HashSet<SignalSystem>> = Vec::new();
+    let mut queue: VecDeque<SignalSystem> = VecDeque::new();
+
+    for signal in seeds {
+        levels.insert(*signal, 0);
+        queue.push_back(*signal);
+    }
+
+    while let Some(signal) = queue.pop_front() {
+        let level = *levels.get(&signal).unwrap_or(&0);
+        for downstream in get_downstreams(world, signal) {
+            let next_level = level.saturating_add(1);
+            let current = levels.get(&downstream).copied().unwrap_or(0);
+            if next_level > current {
+                levels.insert(downstream, next_level);
+                queue.push_back(downstream);
+            }
+        }
+    }
+
+    for (signal, level) in levels.iter() {
+        while by_level.len() <= *level as usize {
+            by_level.push(HashSet::new());
+        }
+        by_level[*level as usize].insert(*signal);
+    }
+
+    by_level
+        .into_iter()
+        .map(|level| {
+            let mut signals_at_level: Vec<SignalSystem> = level.into_iter().collect();
+            // Sort by Entity index to get a deterministic, stable order independent of hash iteration.
+            signals_at_level.sort_by_key(|signal| signal.index());
+            signals_at_level
+        })
+        .collect()
+}
+
+// Rebuilds per-signal levels using a Kahn-style topological traversal.
+//
+// - Roots (in-degree 0) start at level 0.
+// - Each node's level is 1 + max(level of its upstreams).
+// - Nodes are bucketed by level for deterministic per-level iteration.
+// - If a cycle or inconsistent edges are detected (not all nodes processed),
+//   this panics because the graph invariants were violated.
+fn rebuild_levels(world: &mut World, state: &mut SignalGraphState) {
+    state.levels.clear();
+    state.by_level.clear();
+
+    let mut all_signals =
+        SystemState::<Query<Entity, (With<SystemRunner>, Allow<Internal>)>>::new(world);
+    let signals = all_signals
+        .get(world)
+        .iter()
+        .map(SignalSystem)
+        .collect::<Vec<_>>();
+
+    let mut in_degree: HashMap<SignalSystem, usize> = HashMap::new();
+    let mut upstreams_map: HashMap<SignalSystem, Vec<SignalSystem>> = HashMap::new();
+    let mut downstreams_map: HashMap<SignalSystem, Vec<SignalSystem>> = HashMap::new();
+
+    for signal in signals {
+        let upstreams = get_upstreams(world, signal);
+        in_degree.insert(signal, upstreams.len());
+        upstreams_map.insert(signal, upstreams.clone());
+        for upstream in upstreams {
+            downstreams_map.entry(upstream).or_default().push(signal);
+        }
+    }
+
+    let mut queue: VecDeque<SignalSystem> = in_degree
+        .iter()
+        .filter_map(|(signal, degree)| if *degree == 0 { Some(*signal) } else { None })
+        .collect();
+
+    let mut processed = 0usize;
+    while let Some(signal) = queue.pop_front() {
+        processed += 1;
+        let upstreams = upstreams_map.get(&signal).cloned().unwrap_or_default();
+        let level = if upstreams.is_empty() {
+            0
+        } else {
+            upstreams
+                .iter()
+                .filter_map(|u| state.levels.get(u))
+                .max()
+                .map(|m| m + 1)
+                .unwrap_or(0)
+        };
+
+        while state.by_level.len() <= level as usize {
+            state.by_level.push(Vec::new());
+        }
+        state.by_level[level as usize].push(signal);
+        state.levels.insert(signal, level);
+
+        if let Some(downstreams) = downstreams_map.get(&signal) {
+            for downstream in downstreams {
+                if let Some(count) = in_degree.get_mut(downstream) {
+                    *count = count.saturating_sub(1);
+                    if *count == 0 {
+                        queue.push_back(*downstream);
+                    }
+                }
+            }
+        }
+    }
+
+    if processed < in_degree.len() {
+        panic!("signal graph contains a cycle or inconsistent edges during level rebuild");
+    }
+
+    for bucket in state.by_level.iter_mut() {
+        bucket.sort_by_key(|signal| signal.index());
+    }
+}
+
+fn update_levels_incremental(world: &mut World, state: &mut SignalGraphState) -> bool {
+    let mut affected: HashSet<SignalSystem> = HashSet::new();
+    let mut queue: VecDeque<SignalSystem> = state.edge_change_seeds.iter().copied().collect();
+
+    while let Some(signal) = queue.pop_front() {
+        if affected.insert(signal) {
+            for downstream in get_downstreams(world, signal) {
+                queue.push_back(downstream);
+            }
+        }
+    }
+    if affected.is_empty() {
+        return true;
+    }
+
+    let mut in_degree: HashMap<SignalSystem, usize> = HashMap::new();
+    let mut upstreams_map: HashMap<SignalSystem, Vec<SignalSystem>> = HashMap::new();
+
+    for signal in affected.iter().copied() {
+        let upstreams = get_upstreams(world, signal);
+        let local_in_degree = upstreams
+            .iter()
+            .filter(|u| affected.contains(&(**u)))
+            .count();
+        in_degree.insert(signal, local_in_degree);
+        upstreams_map.insert(signal, upstreams);
+    }
+
+    let mut queue: VecDeque<SignalSystem> = in_degree
+        .iter()
+        .filter_map(|(signal, degree)| if *degree == 0 { Some(*signal) } else { None })
+        .collect();
+
+    let mut new_levels: HashMap<SignalSystem, u32> = HashMap::new();
+    let mut processed = 0usize;
+
+    while let Some(signal) = queue.pop_front() {
+        processed += 1;
+        let upstreams = upstreams_map.get(&signal).cloned().unwrap_or_default();
+
+        let mut level = 0u32;
+        for upstream in upstreams {
+            let upstream_level = new_levels
+                .get(&upstream)
+                .copied()
+                .or_else(|| state.levels.get(&upstream).copied())
+                .unwrap_or(0);
+            level = level.max(upstream_level.saturating_add(1));
+        }
+
+        new_levels.insert(signal, level);
+
+        for downstream in get_downstreams(world, signal) {
+            if !affected.contains(&downstream) {
+                continue;
+            }
+            if let Some(count) = in_degree.get_mut(&downstream) {
+                *count = count.saturating_sub(1);
+                if *count == 0 {
+                    queue.push_back(downstream);
+                }
+            }
+        }
+    }
+
+    if processed < affected.len() {
+        return false;
+    }
+
+    for signal in affected {
+        if let Some(old_level) = state.levels.get(&signal).copied() {
+            if let Some(bucket) = state.by_level.get_mut(old_level as usize) {
+                if let Some(pos) = bucket.iter().position(|s| *s == signal) {
+                    bucket.remove(pos);
+                }
+            }
+        }
+
+        if let Some(new_level) = new_levels.get(&signal).copied() {
+            while state.by_level.len() <= new_level as usize {
+                state.by_level.push(Vec::new());
+            }
+            insert_sorted_by_index(&mut state.by_level[new_level as usize], signal);
+            state.levels.insert(signal, new_level);
+        } else {
+            state.levels.remove(&signal);
+        }
+    }
+
+    true
+}
+
+fn update_edge_change_levels(world: &mut World, state: &mut SignalGraphState) {
+    if state.levels.is_empty() {
+        rebuild_levels(world, state);
+        state.edge_change_seeds.clear();
+        return;
+    }
+
+    if state.edge_change_seeds.is_empty() {
+        return;
+    }
+
+    if !update_levels_incremental(world, state) {
+        panic!("signal graph contains a cycle or inconsistent edges during incremental update");
+    }
+    state.edge_change_seeds.clear();
+}
+
+fn remove_signal_from_graph_state_internal(state: &mut SignalGraphState, signal: SignalSystem) {
+    if let Some(level) = state.levels.remove(&signal) {
+        if let Some(bucket) = state.by_level.get_mut(level as usize) {
+            if let Some(pos) = bucket.iter().position(|s| *s == signal) {
+                bucket.remove(pos);
+            }
+        }
+    }
+    state.edge_change_seeds.remove(&signal);
+}
+
+fn remove_signal_from_graph_state(world: &mut World, signal: SignalSystem) {
+    if let Some(mut state) = world.get_resource_mut::<SignalGraphState>() {
+        if state.is_processing {
+            state.deferred_removals.insert(signal);
+            return;
+        }
+        remove_signal_from_graph_state_internal(&mut state, signal);
+    }
+}
+
+fn apply_deferred_removals(state: &mut SignalGraphState) {
+    if state.deferred_removals.is_empty() {
+        return;
+    }
+    let removals = state.deferred_removals.drain().collect::<Vec<_>>();
+    for signal in removals {
+        remove_signal_from_graph_state_internal(state, signal);
+    }
+}
+
+fn process_signal(
+    world: &mut World,
+    signal: SignalSystem,
+    inputs: &mut HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>>,
+) {
+    let runner = match world.get::<SystemRunner>(*signal).cloned() {
+        Some(runner) => runner,
+        None => {
+            if world.get_entity(*signal).is_err() {
+                // Re-entrant combinators can despawn signals during the same frame; skip these stale IDs.
+                return;
+            }
+            let upstreams = get_upstreams(world, signal);
+            let downstreams = get_downstreams(world, signal);
+            panic!(
+                "missing SystemRunner for signal {:?} during processing (entity exists). upstreams={:?}, downstreams={:?}",
+                signal,
+                upstreams,
+                downstreams
+            );
+        }
+    };
+
+    let upstreams = get_upstreams(world, signal);
+
+    if upstreams.is_empty() {
+        if let Some(output) = runner.run(world, Box::new(())) {
+            enqueue_inputs(world, inputs, signal, output);
+        }
+        return;
+    }
+
+    let mut queue = inputs.remove(&signal).unwrap_or_default();
+    while let Some(input) = queue.pop_front() {
+        if let Some(output) = runner.run(world, input) {
+            enqueue_inputs(world, inputs, signal, output);
+        }
+    }
+}
+
 pub(crate) fn process_signals(
     world: &mut World,
-    signals: impl IntoIterator<Item = SignalSystem>,
+    signals: impl AsRef<[SignalSystem]>,
     input: Box<dyn AnyClone>,
 ) {
-    let mut iter = signals.into_iter().peekable();
-    if let Some(first_signal) = iter.next() {
-        // avoid cloning the input if there's only a single downstream, according to
-        // gemini, the compiler cannot do this automatically
-        if iter.peek().is_none() {
-            if let Some(runner) = world
-                .get_entity(*first_signal)
-                .ok()
-                .and_then(|entity| entity.get::<SystemRunner>().cloned())
-                && let Some(output) = runner.run(world, input)
-                && let Some(downstream) = world.get::<Downstream>(*first_signal).cloned()
-            {
-                process_signals(world, downstream.0, output);
+    let signals = signals.as_ref();
+    if signals.is_empty() {
+        return;
+    }
+
+    let mut inputs: HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>> = HashMap::new();
+    let mut iter = signals.iter().copied().peekable();
+    if let Some(first) = iter.next() {
+        let mut run_with_input = |signal: SignalSystem, input: Box<dyn AnyClone>| {
+            let runner = world
+                .get::<SystemRunner>(*signal)
+                .cloned()
+                .unwrap_or_else(|| {
+                    panic!(
+                        "missing SystemRunner for signal {:?} during processing",
+                        signal
+                    )
+                });
+            if let Some(output) = runner.run(world, input) {
+                enqueue_inputs(world, &mut inputs, signal, output);
             }
+        };
+
+        if iter.peek().is_none() {
+            // avoid cloning if there's only a single downstream
+            run_with_input(first, input);
         } else {
-            for signal in [first_signal].into_iter().chain(iter) {
-                if let Some(runner) = world
-                    .get_entity(*signal)
-                    .ok()
-                    .and_then(|entity| entity.get::<SystemRunner>().cloned())
-                    && let Some(output) = runner.run(world, input.clone())
-                    && let Some(downstream) = world.get::<Downstream>(*signal).cloned()
-                {
-                    process_signals(world, downstream.0, output);
+            let rest: Vec<SignalSystem> = iter.collect();
+            if let Some((last, rest)) = rest.split_last() {
+                for signal in core::iter::once(first).chain(rest.iter().copied()) {
+                    run_with_input(signal, input.clone());
                 }
+                run_with_input(*last, input);
             }
         }
     }
+
+    let by_level = downstream_levels_from_seeds(world, signals);
+    let skip: HashSet<SignalSystem> = signals.iter().copied().collect();
+    for level in by_level.into_iter().skip(1) {
+        for signal in level {
+            if skip.contains(&signal) {
+                continue;
+            }
+            process_signal(world, signal, &mut inputs);
+        }
+    }
 }
 
 pub(crate) fn process_signal_graph(world: &mut World) {
-    let mut orphan_parents =
-        SystemState::<Query<Entity, (With<SystemRunner>, Without<Upstream>, Allow<Internal>)>>::new(world);
-    let orphan_parents = orphan_parents.get(world);
-    let orphan_parents = orphan_parents.iter().map(SignalSystem).collect::<Vec<_>>();
-    process_signals(world, orphan_parents, Box::new(()));
+    let mut levels_snapshot: Vec<Vec<SignalSystem>> = Vec::new();
+    world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+        update_edge_change_levels(world, &mut state);
+        state.is_processing = true;
+        levels_snapshot = core::mem::take(&mut state.by_level);
+    });
+
+    let mut inputs: HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>> = HashMap::new();
+    for level in &levels_snapshot {
+        for &signal in level {
+            process_signal(world, signal, &mut inputs);
+        }
+    }
+
+    let mut state = world.resource_mut::<SignalGraphState>();
+    state.is_processing = false;
+    state.by_level = levels_snapshot;
+    apply_deferred_removals(&mut state);
 }
 
 /// Handle to a particular node of the signal graph, returned by
@@ -316,21 +729,21 @@ where
     IOO: Into<Option<O>> + 'static,
     F: IntoSystem<In<I>, IOO, M> + 'static,
 {
-    let sys_id = world.register_system(system);
-    let entity = sys_id.entity();
-
-    // Wrap the typed node behind NodeErased
+    let signal_system = world.register_system(system);
     let runner: Arc<Box<dyn Runnable>> = Arc::new(Box::new(SystemHolder::<I, O, IOO> {
-        system: sys_id,
+        system: signal_system,
         _marker: PhantomData,
     }));
-    world.entity_mut(entity).insert((
+    world.entity_mut(signal_system.entity()).insert((
         SignalRegistrationCount::new(),
         SystemRunner {
             runner: Arc::new(Box::new(move |w, inp| runner.run(w, inp))),
         },
     ));
-    entity.into()
+    if let Some(mut state) = world.get_resource_mut::<SignalGraphState>() {
+        state.edge_change_seeds.insert(signal_system.entity().into());
+    }
+    signal_system.into()
 }
 
 pub(crate) struct LazySignalState {
@@ -414,14 +827,37 @@ pub(crate) struct LazySignalHolder(LazySignal);
 
 pub(crate) static STALE_SIGNALS: LazyLock<Mutex<Vec<SignalSystem>>> = LazyLock::new(|| Mutex::new(Vec::new()));
 
+fn unlink_downstreams_and_mark(world: &mut World, signal: SignalSystem) {
+    if let Some(downstreams) = world.get::<Downstream>(*signal).cloned() {
+        for &downstream in downstreams.iter() {
+            if let Ok(mut downstream_entity) = world.get_entity_mut(*downstream)
+                && let Some(mut upstream) = downstream_entity.get_mut::<Upstream>()
+            {
+                upstream.0.remove(&signal);
+                if upstream.0.is_empty() {
+                    downstream_entity.remove::<Upstream>();
+                }
+            }
+            if let Some(mut state) = world.get_resource_mut::<SignalGraphState>() {
+                state.edge_change_seeds.insert(downstream);
+            }
+        }
+    }
+}
+
 pub(crate) fn despawn_stale_signals(world: &mut World) {
     let signals = STALE_SIGNALS.lock().unwrap().drain(..).collect::<Vec<_>>();
     for signal in signals {
-        if let Ok(entity) = world.get_entity_mut(*signal)
-            && let Some(registration_count) = entity.get::<SignalRegistrationCount>()
-            && **registration_count == 0
-        {
-            entity.despawn();
+        let should_despawn = world
+            .get::<SignalRegistrationCount>(*signal)
+            .map(|registration_count| **registration_count == 0)
+            .unwrap_or(false);
+        if should_despawn {
+            unlink_downstreams_and_mark(world, signal);
+            remove_signal_from_graph_state(world, signal);
+            if let Ok(entity) = world.get_entity_mut(*signal) {
+                entity.despawn();
+            }
         }
     }
 }
@@ -511,57 +947,66 @@ where
     }
 }
 
-fn cleanup_recursive(world: &mut World, signal: SignalSystem) {
-    // 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;
+fn decrement_registration_and_needs_cleanup(world: &mut World, signal: SignalSystem) -> bool {
     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;
+        return **count == 0;
+    }
+    false
+}
+
+fn should_despawn_signal(world: &World, signal: SignalSystem) -> bool {
+    world
+        .get_entity(*signal)
+        .ok()
+        .map(|entity| {
+            if let Some(lazy_holder) = entity.get::<LazySignalHolder>() {
+                lazy_holder.0.inner.references.load(Ordering::SeqCst) == 1
+            } else {
+                // This is a dynamically created signal without a holder, it can be despawned once
+                // its registrations are gone.
+                true
+            }
+        })
+        .unwrap_or(false)
+}
+
+fn unlink_from_upstream(world: &mut World, upstream_system: SignalSystem, signal: SignalSystem) {
+    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>();
         }
     }
+}
 
-    // If the count is not zero, we're done with this branch of the graph.
-    if !needs_full_cleanup {
+fn cleanup_recursive(world: &mut World, signal: SignalSystem) {
+    // Stage 1: Decrement registration and bail if the node is still in use.
+    if !decrement_registration_and_needs_cleanup(world, signal) {
         return;
     }
 
-    // Stage 2: The count is zero. Perform the full cleanup. First, get the list of
-    // parents.
+    // Stage 2: The count is zero. Perform the full cleanup. First, get the list of parents.
     let upstreams = world.get::<Upstream>(*signal).cloned();
 
-    // 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) {
-        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 a holder, it can be despawned once
-            // its registrations are gone.
+    // Unlink downstream edges and mark affected nodes for level recomputation.
+    unlink_downstreams_and_mark(world, signal);
+
+    if should_despawn_signal(world, signal) {
+        remove_signal_from_graph_state(world, signal);
+        if let Ok(entity) = world.get_entity_mut(*signal) {
             entity.despawn();
         }
     }
 
-    // Stage 3: Notify parents and recurse. This happens _after_ the current node has
-    // been processed and potentially despawned.
+    // Stage 3: Notify parents and recurse after processing this node.
     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>();
-                }
-            }
-
-            // Now, recurse on the parent.
+            unlink_from_upstream(world, upstream_system, signal);
             cleanup_recursive(world, upstream_system);
         }
     }
@@ -579,13 +1024,15 @@ fn poll_signal_one_shot(In(signal): In<SignalSystem>, world: &mut World) -> Opti
         }
 
         // 2. pull runner + upstream list
-        let runner = match world.get::<SystemRunner>(*node) {
-            Some(r) => r.clone(),
-            None => {
-                cache.insert(node, None);
-                return None;
-            }
-        };
+        let runner = world
+            .get::<SystemRunner>(*node)
+            .cloned()
+            .unwrap_or_else(|| {
+                panic!(
+                    "missing SystemRunner for signal {:?} during processing",
+                    node
+                )
+            });
         let upstreams: Vec<SignalSystem> = world
             .get::<Upstream>(*node)
             .map(|u| {
@@ -640,3 +1087,153 @@ pub fn poll_signal(world: &mut World, signal: SignalSystem) -> Option<Box<dyn An
 pub fn downcast_any_clone<T: 'static>(any_clone: Box<dyn AnyClone>) -> Option<T> {
     (any_clone as Box<dyn Any>).downcast::<T>().map(|o| *o).ok()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy_ecs::prelude::{In, Mut, World};
+
+    #[derive(Resource, Default)]
+    struct Order(Vec<&'static str>);
+
+    #[test]
+    #[should_panic(expected = "signal graph contains a cycle or inconsistent edges during incremental update")]
+    fn incremental_update_panics_on_cycle() {
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        let signal_a = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(1));
+        let signal_b = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(2));
+
+        world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            rebuild_levels(world, &mut state);
+        });
+
+        world
+            .entity_mut(*signal_a)
+            .insert(Downstream(HashSet::from([signal_b])))
+            .insert(Upstream(HashSet::from([signal_b])));
+        world
+            .entity_mut(*signal_b)
+            .insert(Downstream(HashSet::from([signal_a])))
+            .insert(Upstream(HashSet::from([signal_a])));
+
+        world
+            .resource_mut::<SignalGraphState>()
+            .edge_change_seeds
+            .insert(signal_a);
+
+        world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            update_edge_change_levels(world, &mut state);
+        });
+    }
+
+    #[test]
+    fn ordering_is_deterministic_with_multiple_roots() {
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+        world.insert_resource(Order::default());
+
+        let signal_a = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>, mut order: ResMut<Order>| {
+            order.0.push("a");
+            Some(())
+        });
+        let signal_b = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>, mut order: ResMut<Order>| {
+            order.0.push("b");
+            Some(())
+        });
+
+        process_signal_graph(&mut world);
+
+        let order = world.resource::<Order>().0.clone();
+        if signal_a.0.index() < signal_b.0.index() {
+            assert_eq!(order, vec!["a", "b"]);
+        } else {
+            assert_eq!(order, vec!["b", "a"]);
+        }
+    }
+
+    #[test]
+    fn piping_updates_levels_for_same_frame_execution() {
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+        world.insert_resource(Order::default());
+
+        let signal_a = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>, mut order: ResMut<Order>| {
+            order.0.push("a");
+            Some(())
+        });
+        let signal_b = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>, mut order: ResMut<Order>| {
+            order.0.push("b");
+            Some(())
+        });
+
+        process_signal_graph(&mut world);
+        world.resource_mut::<Order>().0.clear();
+
+        pipe_signal(&mut world, signal_a, signal_b);
+        process_signal_graph(&mut world);
+
+        let order = world.resource::<Order>().0.clone();
+        assert_eq!(order, vec!["a", "b"]);
+    }
+
+    #[test]
+    fn incremental_matches_full_rebuild_after_edge_change() {
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        let a = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>| Some(()));
+        let b = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>| Some(()));
+        let c = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>| Some(()));
+        let d = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>| Some(()));
+
+        pipe_signal(&mut world, a, b);
+        pipe_signal(&mut world, b, c);
+        pipe_signal(&mut world, a, d);
+
+        world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            rebuild_levels(world, &mut state);
+        });
+
+        pipe_signal(&mut world, c, d);
+
+        let incremental_levels = world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            update_edge_change_levels(world, &mut state);
+            state.levels.clone()
+        });
+
+        let mut expected = SignalGraphState::default();
+        rebuild_levels(&mut world, &mut expected);
+
+        assert_eq!(incremental_levels, expected.levels);
+    }
+
+    #[test]
+    fn cleanup_updates_downstream_levels() {
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        let a = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>| Some(()));
+        let b = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>| Some(()));
+        let c = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>| Some(()));
+
+        pipe_signal(&mut world, a, b);
+        pipe_signal(&mut world, b, c);
+
+        world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            rebuild_levels(world, &mut state);
+        });
+
+        cleanup_recursive(&mut world, a);
+
+        let levels_after = world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            update_edge_change_levels(world, &mut state);
+            state.levels.clone()
+        });
+
+        assert_eq!(levels_after.get(&b), Some(&0));
+        assert_eq!(levels_after.get(&c), Some(&1));
+        assert!(!levels_after.contains_key(&a));
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 827781e..d7496de 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -92,6 +92,7 @@ pub struct SignalProcessing;
 
 impl Plugin for JonmoPlugin {
     fn build(&self, app: &mut App) {
+        app.init_resource::<graph::SignalGraphState>();
         app.add_systems(
             self.schedule,
             (
diff --git a/src/signal.rs b/src/signal.rs
index a542e11..4578b60 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -352,11 +352,8 @@ where
     Left: Signal,
     Right: Signal,
 {
-    #[allow(clippy::type_complexity)]
-    left_wrapper: Map<Left, (Option<Left::Item>, Option<Right::Item>)>,
-    #[allow(clippy::type_complexity)]
-    right_wrapper: Map<Right, (Option<Left::Item>, Option<Right::Item>)>,
     signal: LazySignal,
+    _marker: PhantomData<fn() -> (Left, Right)>,
 }
 
 impl<Left, Right> Clone for With<Left, Right>
@@ -366,9 +363,27 @@ where
 {
     fn clone(&self) -> Self {
         Self {
-            left_wrapper: self.left_wrapper.clone(),
-            right_wrapper: self.right_wrapper.clone(),
             signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+/// Internal cache for [`.with`](SignalExt::with) combinator.
+///
+/// Each upstream updates its side. The gate signal runs once per frame and emits the latest
+/// combined output once both sides have produced at least one value.
+#[derive(Component)]
+struct WithCache<L, R> {
+    left: Option<L>,
+    right: Option<R>,
+}
+
+impl<L, R> Default for WithCache<L, R> {
+    fn default() -> Self {
+        Self {
+            left: None,
+            right: None,
         }
     }
 }
@@ -381,12 +396,7 @@ where
     type Item = (Left::Item, Right::Item);
 
     fn register_boxed_signal(self: Box<Self>, world: &mut World) -> SignalHandle {
-        let SignalHandle(left_upstream) = self.left_wrapper.register(world);
-        let SignalHandle(right_upstream) = self.right_wrapper.register(world);
-        let signal = self.signal.register(world);
-        pipe_signal(world, left_upstream, signal);
-        pipe_signal(world, right_upstream, signal);
-        signal.into()
+        self.signal.register(world).into()
     }
 }
 
@@ -1645,7 +1655,7 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// Combines this [`Signal`] with another [`Signal`], outputting a tuple with both of their
+    /// Combines this [`Signal`] with another [`Signal`], outputting a tuple with both of their latest
     /// outputs. The resulting [`Signal`] will only output a value when both input [`Signal`]s have
     /// outputted a value.
     ///
@@ -1663,33 +1673,52 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Other: Signal,
-        Self::Item: Clone + Send + 'static,
-        Other::Item: Clone + Send + 'static,
+        Self::Item: Clone + SSs,
+        Other::Item: Clone + SSs,
     {
-        let left_wrapper = self.map(|In(left): In<Self::Item>| (Some(left), None::<Other::Item>));
-        let right_wrapper = other.map(|In(right): In<Other::Item>| (None::<Self::Item>, Some(right)));
-        let signal = lazy_signal_from_system::<_, (Self::Item, Other::Item), _, _, _>(
-            #[allow(clippy::type_complexity)]
-            move |In((left_option, right_option)): In<(Option<Self::Item>, Option<Other::Item>)>,
-                  mut left_cache: Local<Option<Self::Item>>,
-                  mut right_cache: Local<Option<Other::Item>>| {
-                if left_option.is_some() {
-                    *left_cache = left_option;
-                }
-                if right_option.is_some() {
-                    *right_cache = right_option;
+        let signal = LazySignal::new(move |world: &mut World| {
+            let with_entity = LazyEntity::new();
+
+            let left_wrapper = self.map(clone!((with_entity) move |In(left): In<Self::Item>, world: &mut World| {
+                if let Some(mut cache) = world.get_mut::<WithCache<Self::Item, Other::Item>>(with_entity.get()) {
+                    cache.left = Some(left);
                 }
-                if left_cache.is_some() && right_cache.is_some() {
-                    left_cache.clone().zip(right_cache.clone())
-                } else {
-                    None
+            }));
+            let right_wrapper = other.map(clone!((with_entity) move |In(right): In<Other::Item>, world: &mut World| {
+                if let Some(mut cache) = world.get_mut::<WithCache<Self::Item, Other::Item>>(with_entity.get()) {
+                    cache.right = Some(right);
                 }
-            },
-        );
+            }));
+
+            let with_signal = lazy_signal_from_system::<_, (Self::Item, Other::Item), _, _, _>(
+                clone!((with_entity) move |_: In<()>, world: &mut World| {
+                    let Some(cache) = world.get_mut::<WithCache<Self::Item, Other::Item>>(with_entity.get()) else {
+                        return None;
+                    };
+                    match (&cache.left, &cache.right) {
+                        (Some(left), Some(right)) => Some((left.clone(), right.clone())),
+                        _ => None,
+                    }
+                }),
+            );
+
+            let signal = with_signal.register(world);
+            if let Ok(mut entity) = world.get_entity_mut(*signal) {
+                entity.insert(WithCache::<Self::Item, Other::Item>::default());
+            }
+            with_entity.set(*signal);
+
+            let SignalHandle(left_upstream) = left_wrapper.register(world);
+            let SignalHandle(right_upstream) = right_wrapper.register(world);
+            pipe_signal(world, left_upstream, signal);
+            pipe_signal(world, right_upstream, signal);
+
+            signal
+        });
+
         With {
-            left_wrapper,
-            right_wrapper,
             signal,
+            _marker: PhantomData,
         }
     }
 
@@ -3258,6 +3287,9 @@ mod tests {
     #[derive(Resource, Default, Debug)]
     struct SignalOutput<T: SSs + Clone + fmt::Debug>(Option<T>);
 
+    #[derive(Resource, Default, Debug)]
+    struct SignalOutputVec<T: SSs + Clone + fmt::Debug>(Vec<T>);
+
     fn create_test_app() -> App {
         let mut app = App::new();
         app.add_plugins((MinimalPlugins, JonmoPlugin::default()));
@@ -3278,6 +3310,17 @@ mod tests {
         world.resource::<SignalOutput<T>>().0.clone()
     }
 
+    fn capture_output_vec<T: SSs + Clone + fmt::Debug>(In(value): In<T>, mut output: ResMut<SignalOutputVec<T>>) {
+        output.0.push(value);
+    }
+
+    fn get_and_clear_output_vec<T: SSs + Clone + fmt::Debug>(world: &mut World) -> Vec<T> {
+        world
+            .get_resource_mut::<SignalOutputVec<T>>()
+            .map(|mut res| core::mem::take(&mut res.0))
+            .unwrap_or_default()
+    }
+
     #[test]
     fn test_map() {
         let mut app = create_test_app();
@@ -3721,6 +3764,89 @@ mod tests {
         signal.cleanup(app.world_mut());
     }
 
+    #[test]
+    fn test_with_emits_after_both_emit() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutputVec<(i32, i32)>>();
+
+        let left = SignalBuilder::from_system(|_: In<()>, mut state: Local<i32>| {
+            *state += 1;
+            *state
+        });
+        let right = SignalBuilder::from_system(|_: In<()>| 10).first();
+
+        let signal = left
+            .with(right)
+            .map(capture_output_vec)
+            .register(app.world_mut());
+
+        app.update();
+        assert_eq!(
+            get_and_clear_output_vec::<(i32, i32)>(app.world_mut()),
+            vec![(1, 10), (1, 10)]
+        );
+
+        app.update();
+        assert_eq!(
+            get_and_clear_output_vec::<(i32, i32)>(app.world_mut()),
+            vec![(2, 10)]
+        );
+
+        app.update();
+        assert_eq!(
+            get_and_clear_output_vec::<(i32, i32)>(app.world_mut()),
+            vec![(3, 10)]
+        );
+
+        signal.cleanup(app.world_mut());
+    }
+
+    #[test]
+    fn test_chain_multi_level_same_frame() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<i32>>();
+
+        let signal = SignalBuilder::from_system(|_: In<()>, mut state: Local<i32>| {
+            *state += 1;
+            *state
+        })
+        .map_in(|x: i32| x + 1)
+        .map_in(|x: i32| x * 2)
+        .map(capture_output)
+        .register(app.world_mut());
+
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(4));
+        signal.cleanup(app.world_mut());
+    }
+
+    #[test]
+    fn test_fan_out_fan_in_with() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<(i32, i32)>>();
+
+        let source = SignalBuilder::from_system(|_: In<()>, mut state: Local<i32>| {
+            *state += 1;
+            *state
+        });
+
+        let left = source.clone().map_in(|x: i32| x + 1);
+        let right = source.map_in(|x: i32| x + 10);
+
+        let signal = left
+            .with(right)
+            .map(capture_output)
+            .register(app.world_mut());
+
+        app.update();
+        assert_eq!(get_output::<(i32, i32)>(app.world()), Some((2, 11)));
+
+        app.update();
+        assert_eq!(get_output::<(i32, i32)>(app.world()), Some((3, 12)));
+
+        signal.cleanup(app.world_mut());
+    }
+
     #[test]
     fn test_zip_macro() {
         use crate::signal::zip;

From 2f0ed351d5579aeb5f04773d117777d7612feb13 Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Sun, 18 Jan 2026 20:33:30 -0800
Subject: [PATCH 10/15] check

---
 CHANGELOG.md   |  2 +-
 src/builder.rs | 96 +++++++++++++++++++++++++-------------------------
 src/graph.rs   |  5 +--
 src/lib.rs     |  2 +-
 src/signal.rs  | 48 ++++++++++++-------------
 5 files changed, 77 insertions(+), 76 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0ba784e..eddd507 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ### changed
 
-- `JonmoBuilder::hold_signals` takes `Box<dyn Holdable>`s instead of `SignalHandles`
+- `JonmoBuilder::hold_tasks` renamed to `JonmoBuilder::hold_signals` and takes `Box<dyn SignalTask>`s instead of `SignalHandles`
 - removed output `Clone` bound from `SignalExt::filter_map`
 
 ### added
diff --git a/src/builder.rs b/src/builder.rs
index 184d142..7d75009 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -119,10 +119,10 @@ impl JonmoBuilder {
         })
     }
 
-    /// Attach [`Holdable`] signals to this entity for automatic cleanup on despawn.
+    /// Attach [`SignalTask`]s to this builder for automatic cleanup on despawn.
     ///
-    /// Use [`.hold()`](SignalHoldExt::hold) to convert a [`Signal`], [`SignalVec`], or
-    /// [`SignalMap`] into a [`Holdable`].
+    /// Use [`.task()`](SignalTaskExt::task) to convert a [`Signal`], [`SignalVec`], or
+    /// [`SignalMap`] into a [`SignalTask`].
     ///
     /// # Example
     ///
@@ -135,22 +135,22 @@ impl JonmoBuilder {
     ///     value: i32,
     /// }
     ///
-    /// let my_signal = SignalBuilder::from_resource::<MyResource>()
+    /// let my_signal_task = SignalBuilder::from_resource::<MyResource>()
     ///     .map_in(|r: MyResource| println!("{}", r.value))
-    ///     .hold();
+    ///     .task();
     ///
     /// let mut world = World::new();
     /// let my_mutable_vec = MutableVecBuilder::from([1, 2, 3]).spawn(&mut world);
-    /// let my_signal_vec = my_mutable_vec
+    /// let my_signal_vec_task = my_mutable_vec
     ///     .signal_vec()
     ///     .map_in(|item: i32| println!("{}", item))
-    ///     .hold();
+    ///     .task();
     ///
-    /// JonmoBuilder::new().hold_signals([my_signal, my_signal_vec]);
+    /// JonmoBuilder::new().hold_tasks([my_signal_task, my_signal_vec_task]);
     /// ```
-    pub fn hold_signals(self, holdables: impl IntoIterator<Item = Box<dyn Holdable>> + SSs) -> Self {
+    pub fn hold_tasks(self, tasks: impl IntoIterator<Item = Box<dyn SignalTask>> + SSs) -> Self {
         self.on_spawn(move |world, entity| {
-            let handles: Vec<_> = holdables.into_iter().map(|h| h.register_holdable(world)).collect();
+            let handles: Vec<_> = tasks.into_iter().map(|task| task.register_task(world)).collect();
             add_handles(world, entity, handles);
         })
     }
@@ -194,7 +194,7 @@ impl JonmoBuilder {
     }
 
     /// When this builder's [`Entity`] is despawned, run a function with mutable access to the
-    /// [`DeferredWorld`] and this entity's [`Entity`].
+    /// [`DeferredWorld`] and this builder's [`Entity`].
     pub fn on_despawn(self, on_despawn: impl FnOnce(&mut DeferredWorld, Entity) + Send + Sync + 'static) -> Self {
         self.on_spawn(|world, entity| {
             if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
@@ -787,74 +787,74 @@ impl JonmoBuilder {
     }
 }
 
-/// A type-erased signal that can be registered with a [`World`] at spawn time.
+/// A type-erased signal that can be managed as a free-floating "task".
 ///
-/// This trait enables [`JonmoBuilder::hold_signals`] to accept signals that haven't
+/// This trait enables [`JonmoBuilder::hold_tasks`] to accept signals that haven't
 /// been registered yet, deferring their registration until the entity is spawned.
 ///
-/// Use the [`.hold()`](SignalHoldExt::hold) extension method to convert a [`Signal`],
-/// [`SignalVec`], or [`SignalMap`] into a `Box<dyn Holdable>`.
-pub trait Holdable: Send + Sync + 'static {
-    /// Register this signal with the world and return its handle.
-    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle;
+/// Use the [`.task()`](SignalTaskExt::task) method to convert a [`Signal`],
+/// [`SignalVec`], or [`SignalMap`] into a [`SignalTask`].
+pub trait SignalTask: Send + Sync + 'static {
+    /// Register this signal task with the world and return its handle.
+    fn register_task(self: Box<Self>, world: &mut World) -> SignalHandle;
 }
 
-struct HoldableSignal<S>(S);
+struct SignalTaskSignal<S>(S);
 
-impl<S: Signal + SSs> Holdable for HoldableSignal<S> {
-    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+impl<S: Signal + SSs> SignalTask for SignalTaskSignal<S> {
+    fn register_task(self: Box<Self>, world: &mut World) -> SignalHandle {
         self.0.register(world)
     }
 }
 
-/// Extension trait for converting a [`Signal`] into a [`Holdable`].
-pub trait SignalHoldExt: Signal + Sized + SSs {
-    /// Convert this signal into a type-erased [`Holdable`] for use with
-    /// [`JonmoBuilder::hold_signals`].
-    fn hold(self) -> Box<dyn Holdable> {
-        Box::new(HoldableSignal(self))
+/// Extension trait for converting a [`Signal`] into a [`SignalTask`].
+pub trait SignalTaskExt: Signal + Sized + SSs {
+    /// Convert this signal into a type-erased [`SignalTask`] for use with
+    /// [`JonmoBuilder::hold_tasks`].
+    fn task(self) -> Box<dyn SignalTask> {
+        Box::new(SignalTaskSignal(self))
     }
 }
 
-impl<S: Signal + Sized + SSs> SignalHoldExt for S {}
+impl<S: Signal + Sized + SSs> SignalTaskExt for S {}
 
-struct HoldableSignalVec<S>(S);
+struct SignalTaskSignalVec<S>(S);
 
-impl<S: SignalVec + SSs> Holdable for HoldableSignalVec<S> {
-    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+impl<S: SignalVec + SSs> SignalTask for SignalTaskSignalVec<S> {
+    fn register_task(self: Box<Self>, world: &mut World) -> SignalHandle {
         self.0.register(world)
     }
 }
 
-/// Extension trait for converting a [`SignalVec`] into a [`Holdable`].
-pub trait SignalVecHoldExt: SignalVec + Sized + SSs {
-    /// Convert this signal vec into a type-erased [`Holdable`] for use with
-    /// [`JonmoBuilder::hold_signals`].
-    fn hold(self) -> Box<dyn Holdable> {
-        Box::new(HoldableSignalVec(self))
+/// Extension trait for converting a [`SignalVec`] into a [`SignalTask`].
+pub trait SignalVecTaskExt: SignalVec + Sized + SSs {
+    /// Convert this signal vec into a type-erased [`SignalTask`] for use with
+    /// [`JonmoBuilder::hold_tasks`].
+    fn task(self) -> Box<dyn SignalTask> {
+        Box::new(SignalTaskSignalVec(self))
     }
 }
 
-impl<S: SignalVec + Sized + SSs> SignalVecHoldExt for S {}
+impl<S: SignalVec + Sized + SSs> SignalVecTaskExt for S {}
 
-struct HoldableSignalMap<S>(S);
+struct SignalTaskSignalMap<S>(S);
 
-impl<S: SignalMap + SSs> Holdable for HoldableSignalMap<S> {
-    fn register_holdable(self: Box<Self>, world: &mut World) -> SignalHandle {
+impl<S: SignalMap + SSs> SignalTask for SignalTaskSignalMap<S> {
+    fn register_task(self: Box<Self>, world: &mut World) -> SignalHandle {
         self.0.register(world)
     }
 }
 
-/// Extension trait for converting a [`SignalMap`] into a [`Holdable`].
-pub trait SignalMapHoldExt: SignalMap + Sized + SSs {
-    /// Convert this signal map into a type-erased [`Holdable`] for use with
-    /// [`JonmoBuilder::hold_signals`].
-    fn hold(self) -> Box<dyn Holdable> {
-        Box::new(HoldableSignalMap(self))
+/// Extension trait for converting a [`SignalMap`] into a [`SignalTask`].
+pub trait SignalMapTaskExt: SignalMap + Sized + SSs {
+    /// Convert this signal map into a type-erased [`SignalTask`] for use with
+    /// [`JonmoBuilder::hold_tasks`].
+    fn task(self) -> Box<dyn SignalTask> {
+        Box::new(SignalTaskSignalMap(self))
     }
 }
 
-impl<S: SignalMap + Sized + SSs> SignalMapHoldExt for S {}
+impl<S: SignalMap + Sized + SSs> SignalMapTaskExt for S {}
 
 fn on_despawn_hook(mut world: DeferredWorld, ctx: HookContext) {
     let entity = ctx.entity;
diff --git a/src/graph.rs b/src/graph.rs
index fc4b733..7bced66 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -523,9 +523,9 @@ fn remove_signal_from_graph_state(world: &mut World, signal: SignalSystem) {
     if let Some(mut state) = world.get_resource_mut::<SignalGraphState>() {
         if state.is_processing {
             state.deferred_removals.insert(signal);
-            return;
+        } else {
+            remove_signal_from_graph_state_internal(&mut state, signal);
         }
-        remove_signal_from_graph_state_internal(&mut state, signal);
     }
 }
 
@@ -651,6 +651,7 @@ pub(crate) fn process_signal_graph(world: &mut World) {
     let mut state = world.resource_mut::<SignalGraphState>();
     state.is_processing = false;
     state.by_level = levels_snapshot;
+    // this indirection allows us to avoid cloning the topological ordering every frame
     apply_deferred_removals(&mut state);
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index d7496de..72621ab 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -116,7 +116,7 @@ impl Plugin for JonmoPlugin {
 /// `use jonmo::prelude::*;` imports everything one needs to use start using [jonmo](crate).
 pub mod prelude {
     #[cfg(feature = "builder")]
-    pub use crate::builder::{Holdable, JonmoBuilder, SignalHoldExt, SignalMapHoldExt, SignalVecHoldExt};
+    pub use crate::builder::{JonmoBuilder, SignalMapTaskExt, SignalTask, SignalTaskExt, SignalVecTaskExt};
     pub use crate::{
         JonmoPlugin,
         graph::SignalHandles,
diff --git a/src/signal.rs b/src/signal.rs
index 4578b60..5c639d7 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -2296,8 +2296,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`true`], output the result of some [`System`], otherwise
-    /// terminate for the frame.
+    /// If this [`Signal`] outputs [`true`], output the [`System`] result wrapped in [`Some`], otherwise
+    /// output [`None`].
     ///
     /// # Example
     ///
@@ -2311,7 +2311,7 @@ pub trait SignalExt: Signal {
     ///         *state
     ///     }
     /// })
-    /// .map_true(|_: In<()>| 1); // outputs `1`, terminates, outputs `1`, terminates, ...
+    /// .map_true(|_: In<()>| 1); // outputs `Some(1)`, `None`, `Some(1)`, `None`, ...
     /// ```
     fn map_true<O, F, M>(self, system: F) -> MapTrue<Self, O>
     where
@@ -2342,8 +2342,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`true`], output the result of some [`FnMut`], otherwise
-    /// terminate for the frame.
+    /// If this [`Signal`] outputs [`true`], output the [`FnMut`] result wrapped in [`Some`], otherwise
+    /// output [`None`].
     ///
     /// # Example
     ///
@@ -2357,7 +2357,7 @@ pub trait SignalExt: Signal {
     ///         *state
     ///     }
     /// })
-    /// .map_true_in(|| 1); // outputs `1`, terminates, outputs `1`, terminates, ...
+    /// .map_true_in(|| 1); // outputs `Some(1)`, `None`, `Some(1)`, `None`, ...
     /// ```
     fn map_true_in<O, F>(self, mut function: F) -> MapTrue<Self, O>
     where
@@ -2382,8 +2382,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`false`], output the result of some [`System`], otherwise
-    /// terminate for the frame.
+    /// If this [`Signal`] outputs [`false`], output the [`System`] result wrapped in [`Some`], otherwise
+    /// output [`None`].
     ///
     /// # Example
     ///
@@ -2397,7 +2397,7 @@ pub trait SignalExt: Signal {
     ///         *state
     ///     }
     /// })
-    /// .map_false(|_: In<()>| 1); // terminates, outputs `1`, terminates, outputs `1`, ...
+    /// .map_false(|_: In<()>| 1); // outputs `None`, `Some(1)`, `None`, `Some(1)`, ...
     /// ```
     fn map_false<O, F, M>(self, system: F) -> MapFalse<Self, O>
     where
@@ -2428,8 +2428,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`false`], output the result of some [`FnMut`], otherwise
-    /// terminate for the frame.
+    /// If this [`Signal`] outputs [`false`], output the [`FnMut`] result wrapped in [`Some`], otherwise
+    /// output [`None`].
     ///
     /// # Example
     ///
@@ -2443,7 +2443,7 @@ pub trait SignalExt: Signal {
     ///         *state
     ///     }
     /// })
-    /// .map_false_in(|| 1); // terminates, outputs `1`, terminates, outputs `1`, ...
+    /// .map_false_in(|| 1); // outputs `None`, `Some(1)`, `None`, `Some(1)`, ...
     /// ```
     fn map_false_in<O, F>(self, mut function: F) -> MapFalse<Self, O>
     where
@@ -2561,8 +2561,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`Some`], output the result of some [`System`] which takes [`In`]
-    /// the [`Some`] value, otherwise terminate for the frame.
+    /// If this [`Signal`] outputs [`Some`], output the [`System`] (which takes [`In`] the [`Some`]
+    /// value) result wrapped in [`Some`], otherwise output [`None`].
     ///
     /// # Example
     ///
@@ -2578,7 +2578,7 @@ pub trait SignalExt: Signal {
     /// })
     /// .map_some(
     ///     |In(state): In<bool>| state
-    /// ); // outputs `true`, terminates, outputs `true`, terminates, ...
+    /// ); // outputs `Some(true)`, `None`, `Some(true)`, `None`, ...
     /// ```
     fn map_some<I, O, F, M>(self, system: F) -> MapSome<Self, O>
     where
@@ -2607,8 +2607,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`Some`], output the result of some [`FnMut`] which takes [`In`]
-    /// the [`Some`] value, otherwise terminate for the frame.
+    /// If this [`Signal`] outputs [`Some`], output the [`FnMut`] (which takes [`In`] the [`Some`]
+    /// value) result wrapped in [`Some`], otherwise output [`None`].
     ///
     /// # Example
     ///
@@ -2622,7 +2622,7 @@ pub trait SignalExt: Signal {
     ///        *state
     ///     }
     /// })
-    /// .map_some_in(|state: bool| state); // outputs `true`, terminates, outputs `true`, terminates, ...
+    /// .map_some_in(|state: bool| state); // outputs `Some(true)`, `None`, `Some(true)`, `None`, ...
     /// ```
     fn map_some_in<I, O, F>(self, mut function: F) -> MapSome<Self, O>
     where
@@ -2647,8 +2647,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`None`], output the result of some [`System`], otherwise
-    /// terminate for the frame.
+    /// If this [`Signal`] outputs [`None`], output the [`System`] result wrapped in [`Some`], otherwise
+    /// output [`None`].
     ///
     /// # Example
     ///
@@ -2662,7 +2662,7 @@ pub trait SignalExt: Signal {
     ///         *state
     ///     }
     /// })
-    /// .map_none(|_: In<()>| false); // terminates, outputs `false`, terminates, outputs `false`, ...
+    /// .map_none(|_: In<()>| false); // outputs `None`, `Some(false)`, `None`, `Some(false)`, ...
     /// ```
     fn map_none<I, O, F, M>(self, none_system: F) -> MapNone<Self, O>
     where
@@ -2691,8 +2691,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`None`], output the result of some [`FnMut`], otherwise
-    /// terminate for the frame.
+    /// If this [`Signal`] outputs [`None`], output the [`FnMut`] result wrapped in [`Some`], otherwise
+    /// output [`None`].
     ///
     /// # Example
     ///
@@ -2706,7 +2706,7 @@ pub trait SignalExt: Signal {
     ///         *state
     ///     }
     /// })
-    /// .map_none_in(|| false); // terminates, outputs `false`, terminates, outputs `false`, ...
+    /// .map_none_in(|| false); // outputs `None`, `Some(false)`, `None`, `Some(false)`, ...
     /// ```
     fn map_none_in<I, O, F>(self, mut function: F) -> MapNone<Self, O>
     where

From fb62d25ffa86ccca8e1eee0d28a061fd4b17e77a Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Sat, 24 Jan 2026 14:46:16 -0800
Subject: [PATCH 11/15] check

---
 CHANGELOG.md                     |   12 +-
 Cargo.toml                       |    2 +-
 README.md                        |   25 +-
 examples/basic.rs                |    3 +-
 examples/basic_builder.rs        |   20 +-
 examples/basic_builder_inject.rs |   17 +-
 examples/counter.rs              |   59 +-
 examples/filters.rs              |  140 +-
 examples/letters.rs              |   57 +-
 examples/lifetimes.rs            |   40 +-
 examples/test.rs                 |   28 +-
 src/builder.rs                   | 2444 +++++-------------------------
 src/graph.rs                     |  167 +-
 src/lib.rs                       |   21 +-
 src/signal.rs                    | 1113 ++++++++------
 src/signal_map.rs                |  230 ++-
 src/signal_vec.rs                |  619 ++++----
 17 files changed, 1829 insertions(+), 3168 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eddd507..9197bd2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,13 +6,19 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ### changed
 
-- `JonmoBuilder::hold_tasks` renamed to `JonmoBuilder::hold_signals` and takes `Box<dyn SignalTask>`s instead of `SignalHandles`
-- removed output `Clone` bound from `SignalExt::filter_map`
+- signal graph processed in deterministic topological order instead of the previous nondeterministic depth first order
+- renamed `SignalExt::combine` to `SignalExt::with`
+- `JonmoBuilder` renamed to `jonmo::Builder`
+- `jonmo::Builder::hold_signals` renamed to `jonmo::Builder::hold_tasks` and takes `Box<dyn SignalTask>`s instead of `SignalHandles`
+- removed self item `Clone` bound from `SignalVecExt::map_signal` and `SignalVecExt::filter_map`
+- `SignalBuilder::*` methods moved to free functions in `signal` module (e.g. `SignalBuilder::always` -> `signal::always`)
 
 ### added
 - `SignalExt::take`
+- `signal::zip!`, a variadic flattened version of `SignalExt::with`
+- `SignalVecExt::flatten`
 - `track_caller` derive for panicking `LazyEntity` methods
-- warning that cloning `JonmoBuilder`s at runtime is a bug
+- warning that cloning `jonmo::Builder`s at runtime is a bug
 
 ### fixed
 
diff --git a/Cargo.toml b/Cargo.toml
index 691cb44..8cd0c6f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ document-features = { version = "0.2", optional = true }
 [features]
 default = ["builder", "tracing", "time", "std"]
 
-## Enables access to jonmo's high-level entity builder, [`JonmoBuilder`](https://docs.rs/jonmo/latest/jonmo/builder/struct.JonmoBuilder.html).
+## Enables access to jonmo's high-level entity builder, [`jonmo::Builder`](https://docs.rs/jonmo/latest/jonmo/builder/struct.Builder.html).
 builder = []
 
 ## Enables access to signal ext `.debug` methods, which conveniently logs signal outputs at any step.
diff --git a/README.md b/README.md
index 13291e8..0ed0806 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@
 in bengali, jonmo means "birth"
 ```
 
-[jonmo](https://github.com/databasedav/jonmo) provides an ergonomic, functional, and declarative API for specifying Bevy [system](https://docs.rs/bevy/latest/bevy/ecs/system/index.html) dependency graphs, where "output" handles to nodes of the graph are canonically referred to as "signals". Building upon these signals, jonmo offers a high level [entity builder](https://docs.rs/jonmo/latest/jonmo/builder/struct.JonmoBuilder.html) which enables one to declare reactive entities, components, and children using a familiar fluent syntax with semantics and API ported from the incredible [FRP](https://en.wikipedia.org/wiki/Functional_reactive_programming) signals of [futures-signals](https://github.com/Pauan/rust-signals) and its web UI dependents [MoonZoon](https://github.com/MoonZoon/MoonZoon) and [Dominator](https://github.com/Pauan/rust-dominator).
+[jonmo](https://github.com/databasedav/jonmo) provides an ergonomic, functional, and declarative API for specifying Bevy [system](https://docs.rs/bevy/latest/bevy/ecs/system/index.html) dependency graphs, where "output" handles to nodes of the graph are canonically referred to as "signals". Building upon these signals, jonmo offers a high level [entity builder](https://docs.rs/jonmo/latest/jonmo/builder/struct.Builder.html) which enables one to declare reactive entities, components, and children using a familiar fluent syntax with semantics and API ported from the incredible [FRP](https://en.wikipedia.org/wiki/Functional_reactive_programming) signals of [futures-signals](https://github.com/Pauan/rust-signals) and its web UI dependents [MoonZoon](https://github.com/MoonZoon/MoonZoon) and [Dominator](https://github.com/Pauan/rust-dominator).
 
 The runtime of jonmo is quite simple; every frame, the outputs of systems are forwarded to their dependants, recursively. The complexity and power of jonmo really emerges from its monadic signal combinators, defined within the [`SignalExt`](https://docs.rs/jonmo/latest/jonmo/signal/trait.SignalExt.html), [`SignalVecExt`](https://docs.rs/jonmo/latest/jonmo/signal_vec/trait.SignalVecExt.html), and [`SignalMapExt`](https://docs.rs/jonmo/latest/jonmo/signal_map/trait.SignalMapExt.html) traits (ported from futures-signals' traits of the same name), which internally manage special Bevy systems that allow for the declarative composition of complex data flows with minimalistic, high-level, signals-oriented methods.
 
@@ -51,10 +51,10 @@ fn main() {
 #[derive(Component, Clone, Deref, DerefMut)]
 struct Counter(i32);
 
-fn ui_root() -> JonmoBuilder {
+fn ui_root() -> jonmo::Builder {
     let counter_holder = LazyEntity::new();
 
-    JonmoBuilder::from(Node {
+    jonmo::Builder::from(Node {
         width: Val::Percent(100.0),
         height: Val::Percent(100.0),
         justify_content: JustifyContent::Center,
@@ -62,7 +62,7 @@ fn ui_root() -> JonmoBuilder {
         ..default()
     })
     .child(
-        JonmoBuilder::from(Node {
+        jonmo::Builder::from(Node {
             flex_direction: FlexDirection::Row,
             column_gap: Val::Px(15.0),
             align_items: AlignItems::Center,
@@ -73,11 +73,10 @@ fn ui_root() -> JonmoBuilder {
         .lazy_entity(counter_holder.clone())
         .child(counter_button(counter_holder.clone(), PINK, "-", -1))
         .child(
-            JonmoBuilder::from((Node::default(), TextFont::from_font_size(25.)))
+            jonmo::Builder::from((Node::default(), TextFont::from_font_size(25.)))
                 .component_signal(
-                    SignalBuilder::from_component_lazy(counter_holder.clone())
-                        .map_in(|counter: Counter| *counter)
-                        .dedupe()
+                    signal::from_component_changed_lazy::<Counter>(counter_holder.clone())
+                        .map_in(deref_copied)
                         .map_in_ref(ToString::to_string)
                         .map_in(Text)
                         .map_in(Some),
@@ -87,8 +86,8 @@ fn ui_root() -> JonmoBuilder {
     )
 }
 
-fn counter_button(counter_holder: LazyEntity, color: Color, label: &'static str, step: i32) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn counter_button(counter_holder: LazyEntity, color: Color, label: &'static str, step: i32) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node {
             width: Val::Px(45.0),
             justify_content: JustifyContent::Center,
@@ -99,11 +98,9 @@ fn counter_button(counter_holder: LazyEntity, color: Color, label: &'static str,
         BackgroundColor(color),
     ))
     .observe(move |_: On<Pointer<Click>>, mut counters: Query<&mut Counter>| {
-        if let Ok(mut counter) = counters.get_mut(*counter_holder) {
-            **counter += step;
-        }
+        **counters.get_mut(*counter_holder).unwrap() += step;
     })
-    .child(JonmoBuilder::from((Text::from(label), TextFont::from_font_size(25.))))
+    .child(jonmo::Builder::from((Text::from(label), TextFont::from_font_size(25.))))
 }
 
 fn camera(mut commands: Commands) {
diff --git a/examples/basic.rs b/examples/basic.rs
index 8fc732a..ede6dee 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -26,8 +26,7 @@ fn ui(world: &mut World) {
     let text = world
         .spawn((Node::default(), TextFont::from_font_size(100.), Value(0)))
         .id();
-    let signal = SignalBuilder::from_component(text)
-        .dedupe()
+    let signal = signal::from_component_changed::<Value>(text)
         .map(move |In(value): In<Value>, mut commands: Commands| {
             commands.entity(text).insert(Text(value.0.to_string()));
         })
diff --git a/examples/basic_builder.rs b/examples/basic_builder.rs
index 798b8cd..f14e903 100644
--- a/examples/basic_builder.rs
+++ b/examples/basic_builder.rs
@@ -29,23 +29,25 @@ struct ValueTicker(Timer);
 #[derive(Component, Clone, Default, PartialEq)]
 struct Value(i32);
 
-fn ui() -> JonmoBuilder {
-    JonmoBuilder::from(Node {
+fn ui() -> jonmo::Builder {
+    let lazy_entity = LazyEntity::new();
+    jonmo::Builder::from(Node {
         justify_content: JustifyContent::Center,
         align_items: AlignItems::Center,
         height: Val::Percent(100.),
         width: Val::Percent(100.),
         ..default()
     })
+    .lazy_entity(lazy_entity.clone())
     .child(
-        JonmoBuilder::from((Node::default(), TextFont::from_font_size(100.)))
+        jonmo::Builder::from((Node::default(), TextFont::from_font_size(100.)))
             .insert(Value(0))
-            .component_signal_from_component(|signal| {
-                signal
-                    .dedupe()
-                    .map(|In(value): In<Value>| Text(value.0.to_string()))
-                    .map_in(Some)
-            }),
+            .component_signal(
+                signal::from_component_changed_lazy::<Value>(lazy_entity)
+                    .map_in(|value| value.0.to_string())
+                    .map_in(Text)
+                    .map_in(Some),
+            ),
     )
 }
 
diff --git a/examples/basic_builder_inject.rs b/examples/basic_builder_inject.rs
index 7a03f2c..e7abf02 100644
--- a/examples/basic_builder_inject.rs
+++ b/examples/basic_builder_inject.rs
@@ -34,14 +34,15 @@ fn ui(world: &mut World) {
     });
     ui_root.add_child(text);
 
-    JonmoBuilder::new()
-        .component_signal_from_component(|signal| {
-            signal
-                .dedupe()
-                .map(|In(value): In<Value>| Text(value.0.to_string()))
-                .map_in(Some)
-        })
-        .spawn_on_entity(world, text);
+    jonmo::Builder::new()
+        .component_signal(
+            signal::from_component_changed::<Value>(text)
+                .map_in(|value| value.0.to_string())
+                .map_in(Text)
+                .map_in(Some),
+        )
+        .spawn_on_entity(world, text)
+        .unwrap();
 }
 
 fn incr_value(mut ticker: ResMut<ValueTicker>, time: Res<Time>, mut values: Query<&mut Value>) {
diff --git a/examples/counter.rs b/examples/counter.rs
index 6f5fae4..9f5d49d 100644
--- a/examples/counter.rs
+++ b/examples/counter.rs
@@ -6,8 +6,8 @@
 //! 1. **World-Driven State**: The application's state (the counter's value) is stored in a standard
 //!    Bevy `Component`, the "single source of truth".
 //!
-//! 2. **Declarative UI with `JonmoBuilder`**: The entire entity hierarchy is defined up-front in a
-//!    clean, colocated, declarative style.
+//! 2. **Declarative UI with `jonmo::Builder`**: The entire entity hierarchy is defined up-front in
+//!    a clean, colocated, declarative style.
 //!
 //! 3. **The `LazyEntity` Pattern**: related entities can refer to the state-holding entity *before*
 //!    it has been spawned, solving a common ordering problem in hierarchical entity construction.
@@ -40,16 +40,15 @@ fn main() {
 #[derive(Component, Clone, Deref, DerefMut)]
 struct Counter(i32);
 
-fn ui_root() -> JonmoBuilder {
-    // --- The `LazyEntity` Pattern ---
+fn ui_root() -> jonmo::Builder {
     // We need the buttons and the text display to know the `Entity` ID of the node
     // that will hold the `Counter` component. However, that node hasn't been spawned yet.
     // `LazyEntity` acts as a placeholder or a "promise" for an entity that will be
-    // spawned by a `JonmoBuilder` later. It can be cloned and passed around freely, e.g. into the
+    // spawned by a `jonmo::Builder` later. It can be cloned and passed around freely, e.g. into the
     // bodies of signal systems.
     let counter_holder = LazyEntity::new();
 
-    JonmoBuilder::from(Node {
+    jonmo::Builder::from(Node {
         width: Val::Percent(100.0),
         height: Val::Percent(100.0),
         justify_content: JustifyContent::Center,
@@ -57,7 +56,7 @@ fn ui_root() -> JonmoBuilder {
         ..default()
     })
     .child(
-        JonmoBuilder::from(Node {
+        jonmo::Builder::from(Node {
             flex_direction: FlexDirection::Row,
             column_gap: Val::Px(15.0),
             align_items: AlignItems::Center,
@@ -65,32 +64,27 @@ fn ui_root() -> JonmoBuilder {
             ..default()
         })
         .insert(Counter(0))
-        // --- Fulfilling the Promise ---
-        // `.lazy_entity()` connects the `LazyEntity` to the actual entity that this `JonmoBuilder` spawns. Now calling
-        // `counter_holder.get()` from other deferred contexts, e.g. in the bodies of signal systems, will return the
-        // `Entity` ID of this row node.
+        // `.lazy_entity()` connects the `LazyEntity` to the actual entity that this `jonmo::Builder` spawns. Now
+        // calling `counter_holder.get()` from other deferred contexts, e.g. in the bodies of signal systems,
+        // will return the `Entity` ID of this row node.
         .lazy_entity(counter_holder.clone())
         .child(counter_button(counter_holder.clone(), PINK, "-", -1))
         .child(
-            JonmoBuilder::from((Node::default(), TextFont::from_font_size(25.)))
-                // --- Reactivity ---
+            jonmo::Builder::from((Node::default(), TextFont::from_font_size(25.)))
                 // `component_signal` is a core fixture of jonmo's reactivity. It takes a signal as an argument and
                 // uses its output to insert or update a component on the entity being built. Here,
                 // we're creating a signal that will produce a `Text` component whenever the counter
                 // changes.
                 .component_signal(
-                    // `SignalBuilder::from_component_lazy` creates a signal that reactively reads a component from an
-                    // entity that doesn't exist yet, identified by our `LazyEntity`.
-                    SignalBuilder::from_component_lazy(counter_holder.clone())
-                        // Rust's type system is intelligent enough to infer the "from_component" target from the
-                        // definition of the system passed to any of jonmo's signal combinators. `map_in` is a shorthand
-                        // for `.map` which unpacks its `In` input; this is especially convenient when the system passed
-                        // to `.map` does not need any other `SystemParam`s. Here, we simply deref the inner counter
-                        // value from the fetched `Counter` component for further transformation.
-                        .map_in(|counter: Counter| *counter)
-                        // `.dedupe()` ensures the rest of the chain only runs when the counter's value *actually
-                        // changes*, preventing redundant updates every frame.
-                        .dedupe()
+                    // `signal::from_component_changed_lazy` creates a signal that reactively reads a component from an
+                    // entity that doesn't exist yet, identified by our `LazyEntity`, only firing when the component
+                    // changes.
+                    signal::from_component_changed_lazy::<Counter>(counter_holder.clone())
+                        // `map_in` is a shorthand for `.map` that takes a regular function instead of a Bevy
+                        // system; this is especially convenient when additional `SystemParam`s aren't necessary.
+                        // `deref_copied` dereferences and copies, extracting the inner `i32` from the `Counter`
+                        // newtype for further transformation.
+                        .map_in(deref_copied)
                         // `Text` expects a `String` and `.to_string` expects a reference
                         .map_in_ref(ToString::to_string)
                         .map_in(Text)
@@ -103,8 +97,8 @@ fn ui_root() -> JonmoBuilder {
     )
 }
 
-fn counter_button(counter_holder: LazyEntity, color: Color, label: &'static str, step: i32) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn counter_button(counter_holder: LazyEntity, color: Color, label: &'static str, step: i32) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node {
             width: Val::Px(45.0),
             justify_content: JustifyContent::Center,
@@ -118,14 +112,11 @@ fn counter_button(counter_holder: LazyEntity, color: Color, label: &'static str,
     .observe(move |_: On<Pointer<Click>>, mut counters: Query<&mut Counter>| {
         // Use the fulfilled `LazyEntity` to get mutable access to the `Counter` component on our
         // state-holding entity.
-        if let Ok(mut counter) = counters.get_mut(*counter_holder) {
-            // --- State Mutation ---
-            // Because our text display has a signal that reads this component, this change will
-            // automatically trigger a UI update at the end of the frame.
-            **counter += step;
-        }
+        **counters.get_mut(*counter_holder).unwrap() += step;
+        // Because our text display has a signal that reads this component, this change will
+        // automatically trigger a UI update at the end of the frame.
     })
-    .child(JonmoBuilder::from((Text::from(label), TextFont::from_font_size(25.))))
+    .child(jonmo::Builder::from((Text::from(label), TextFont::from_font_size(25.))))
 }
 
 fn camera(mut commands: Commands) {
diff --git a/examples/filters.rs b/examples/filters.rs
index 06516b3..2665696 100644
--- a/examples/filters.rs
+++ b/examples/filters.rs
@@ -3,15 +3,19 @@
 mod utils;
 use utils::*;
 
-use bevy::{ecs::system::IntoObserverSystem, platform::collections::HashSet, prelude::*};
-use jonmo::{prelude::*, utils::SSs};
+use bevy::{platform::collections::HashSet, prelude::*};
+use jonmo::prelude::*;
 use rand::{Rng, prelude::IndexedRandom};
 
 fn main() {
     let mut app = App::new();
     let world = app.world_mut();
-    let datas = MutableVecBuilder::from((0..12).map(|_| random_data()).collect::<Vec<_>>()).spawn(world);
-    let rows = MutableVecBuilder::from((0..5).map(|_| ()).collect::<Vec<_>>()).spawn(world);
+    let datas = MutableVec::builder()
+        .with_values(|v| v.extend((0..12).map(|_| random_data())))
+        .spawn(world);
+    let rows = MutableVec::builder()
+        .with_values(|v| v.extend((0..5).map(|_| ())))
+        .spawn(world);
     app.add_plugins(examples_plugin)
         .insert_resource(Datas(datas.clone()))
         .insert_resource(Rows(rows.clone()))
@@ -83,14 +87,14 @@ struct Sorted;
 
 const GAP: f32 = 5.;
 
-fn ui(items: MutableVec<Data>, rows: MutableVec<()>) -> JonmoBuilder {
-    JonmoBuilder::from(Node {
+fn ui(items: MutableVec<Data>, rows: MutableVec<()>) -> jonmo::Builder {
+    jonmo::Builder::from(Node {
         height: Val::Percent(100.),
         width: Val::Percent(100.),
         ..default()
     })
     .child(
-        JonmoBuilder::from(Node {
+        jonmo::Builder::from(Node {
             flex_direction: FlexDirection::Column,
             align_self: AlignSelf::Start,
             justify_self: JustifySelf::Start,
@@ -99,26 +103,26 @@ fn ui(items: MutableVec<Data>, rows: MutableVec<()>) -> JonmoBuilder {
             ..default()
         })
         .child(
-            JonmoBuilder::from((Node {
+            jonmo::Builder::from((Node {
                 flex_direction: FlexDirection::Row,
                 align_items: AlignItems::Center,
                 column_gap: Val::Px(GAP * 2.),
                 ..default()
             },))
-            .child(JonmoBuilder::from((
+            .child(jonmo::Builder::from((
                 Node::default(),
                 Text::new("source"),
                 TextColor(Color::WHITE),
                 TextFont::from_font_size(30.),
                 TextLayout::new_with_justify(Justify::Center),
             )))
-            .child(button("+", -2.).apply(on_click(
+            .child(button("+", -2.).observe(
                 |_: On<Pointer<Click>>, datas: Res<Datas>, mut mutable_vec_datas: Query<&mut MutableVecData<_>>| {
                     datas.0.write(&mut mutable_vec_datas).insert(0, random_data());
                 },
-            )))
+            ))
             .child(
-                JonmoBuilder::from(Node {
+                jonmo::Builder::from(Node {
                     flex_direction: FlexDirection::Row,
                     align_items: AlignItems::Center,
                     column_gap: Val::Px(GAP),
@@ -138,7 +142,7 @@ fn ui(items: MutableVec<Data>, rows: MutableVec<()>) -> JonmoBuilder {
                 .map_in(clone!((items) move |(index, _)| row(index.dedupe(), items.clone()))),
         )
         .child(
-            JonmoBuilder::from((
+            jonmo::Builder::from((
                 Node {
                     height: Val::Px(55.),
                     justify_content: JustifyContent::Center,
@@ -147,11 +151,11 @@ fn ui(items: MutableVec<Data>, rows: MutableVec<()>) -> JonmoBuilder {
                 },
                 // BackgroundColor(Color::WHITE),
             ))
-            .child(button("+", -2.).apply(on_click(
+            .child(button("+", -2.).observe(
                 |_: On<Pointer<Click>>, rows: Res<Rows>, mut mutable_vec_datas: Query<&mut MutableVecData<_>>| {
                     rows.0.write(&mut mutable_vec_datas).push(());
                 },
-            ))),
+            )),
         ),
     )
 }
@@ -189,7 +193,7 @@ fn random_shape_filters() -> ShapeFilters {
     ShapeFilters(HashSet::from_iter(random_subset(&[Shape::Square, Shape::Circle])))
 }
 
-fn maybe_insert_random_sorted(builder: JonmoBuilder) -> JonmoBuilder {
+fn maybe_insert_random_sorted(builder: jonmo::Builder) -> jonmo::Builder {
     let mut rng = rand::rng();
     if rng.random_bool(0.5) {
         builder.insert(Sorted)
@@ -198,8 +202,8 @@ fn maybe_insert_random_sorted(builder: JonmoBuilder) -> JonmoBuilder {
     }
 }
 
-fn text_node(text: &'static str) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn text_node(text: &'static str) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node::default(),
         Text::new(text),
         TextColor(Color::WHITE),
@@ -214,16 +218,6 @@ fn toggle<T: Eq + core::hash::Hash>(set: &mut HashSet<T>, value: T) {
     }
 }
 
-fn on_click<M>(
-    on_click: impl IntoObserverSystem<Pointer<Click>, (), M> + SSs,
-) -> impl FnOnce(JonmoBuilder) -> JonmoBuilder {
-    move |builder: JonmoBuilder| {
-        builder.on_spawn(move |world, entity| {
-            world.entity_mut(entity).observe(on_click);
-        })
-    }
-}
-
 fn outline() -> Outline {
     Outline {
         width: Val::Px(1.),
@@ -231,17 +225,16 @@ fn outline() -> Outline {
     }
 }
 
-fn number_toggle(row_parent: LazyEntity, parity: Parity) -> impl Fn(JonmoBuilder) -> JonmoBuilder {
+fn number_toggle(row_parent: LazyEntity, parity: Parity) -> impl Fn(jonmo::Builder) -> jonmo::Builder {
     move |builder| {
         builder
-            .apply(on_click(
+            .observe(
                 clone!((row_parent) move |_: On<Pointer<Click>>, mut number_filters: Query<&mut NumberFilters>| {
-                    toggle(&mut number_filters.get_mut(row_parent.get()).unwrap().0, parity);
+                    toggle(&mut number_filters.get_mut(*row_parent).unwrap().0, parity);
                 }),
-            ))
+            )
             .component_signal(
-                SignalBuilder::from_component_lazy(row_parent.clone())
-                    .dedupe()
+                signal::from_component_changed_lazy(row_parent.clone())
                     .map_in(move |NumberFilters(filters)| filters.contains(&parity))
                     .dedupe()
                     .map_true(|_: In<()>| outline()),
@@ -249,8 +242,8 @@ fn number_toggle(row_parent: LazyEntity, parity: Parity) -> impl Fn(JonmoBuilder
     }
 }
 
-fn number_toggles(row_parent: LazyEntity) -> JonmoBuilder {
-    JonmoBuilder::from(Node {
+fn number_toggles(row_parent: LazyEntity) -> jonmo::Builder {
+    jonmo::Builder::from(Node {
         flex_direction: FlexDirection::Column,
         row_gap: Val::Px(2.),
         ..default()
@@ -271,16 +264,16 @@ fn number_toggles(row_parent: LazyEntity) -> JonmoBuilder {
         text_node("sort")
             .insert(TextFont::from_font_size(13.))
             .insert(BackgroundColor(bevy::color::palettes::basic::GRAY.into()))
-            .apply(on_click(
+            .observe(
                 clone!((row_parent) move |_: On<Pointer<Click>>, mut commands: Commands| {
                     commands.queue(clone!((row_parent) move |world: &mut World| {
-                        let mut entity = world.entity_mut(row_parent.get());
+                        let mut entity = world.entity_mut(*row_parent);
                         if entity.take::<Sorted>().is_none() { entity.insert(Sorted); }
                     }))
                 }),
-            ))
+            )
             .component_signal(
-                SignalBuilder::from_lazy_entity(row_parent.clone())
+                signal::from_lazy_entity(row_parent.clone())
                     .has_component::<Sorted>()
                     .dedupe()
                     .map_true(|_: In<()>| outline()),
@@ -288,8 +281,8 @@ fn number_toggles(row_parent: LazyEntity) -> JonmoBuilder {
     )
 }
 
-fn shape_toggle(row_parent: LazyEntity, shape: Shape) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn shape_toggle(row_parent: LazyEntity, shape: Shape) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node {
             width: Val::Px(20.),
             height: Val::Px(20.),
@@ -297,22 +290,21 @@ fn shape_toggle(row_parent: LazyEntity, shape: Shape) -> JonmoBuilder {
         },
         BackgroundColor(bevy::color::palettes::basic::GRAY.into()),
     ))
-    .apply(on_click(
+    .observe(
         clone!((row_parent) move |_: On<Pointer<Click>>, mut shape_filters: Query<&mut ShapeFilters>| {
-            toggle(&mut shape_filters.get_mut(row_parent.get()).unwrap().0, shape);
+            toggle(&mut shape_filters.get_mut(*row_parent).unwrap().0, shape);
         }),
-    ))
+    )
     .component_signal(
-        SignalBuilder::from_component_lazy(row_parent.clone())
-            .dedupe()
+        signal::from_component_changed_lazy(row_parent.clone())
             .map_in(move |ShapeFilters(filters)| filters.contains(&shape))
             .dedupe()
             .map_true(|_: In<()>| outline()),
     )
 }
 
-fn shape_toggles(row_parent: LazyEntity) -> JonmoBuilder {
-    JonmoBuilder::from(Node {
+fn shape_toggles(row_parent: LazyEntity) -> jonmo::Builder {
+    jonmo::Builder::from(Node {
         flex_direction: FlexDirection::Column,
         justify_content: JustifyContent::Center,
         row_gap: Val::Px(GAP),
@@ -322,8 +314,8 @@ fn shape_toggles(row_parent: LazyEntity) -> JonmoBuilder {
     .child(shape_toggle(row_parent.clone(), Shape::Circle).insert(BorderRadius::MAX))
 }
 
-fn color_toggles(row_parent: LazyEntity) -> JonmoBuilder {
-    JonmoBuilder::from(Node {
+fn color_toggles(row_parent: LazyEntity) -> jonmo::Builder {
+    jonmo::Builder::from(Node {
         flex_direction: FlexDirection::Column,
         justify_content: JustifyContent::Center,
         row_gap: Val::Px(GAP),
@@ -333,7 +325,7 @@ fn color_toggles(row_parent: LazyEntity) -> JonmoBuilder {
         [ColorEnum::Blue, ColorEnum::Pink, ColorEnum::White]
             .into_iter()
             .map(move |color| {
-                JonmoBuilder::from((
+                jonmo::Builder::from((
                     Node {
                         width: Val::Px(15.),
                         height: Val::Px(15.),
@@ -344,14 +336,13 @@ fn color_toggles(row_parent: LazyEntity) -> JonmoBuilder {
                     BackgroundColor(color.into()),
                     BorderColor::all(Color::BLACK),
                 ))
-                .apply(on_click(
+                .observe(
                     clone!((row_parent) move |_: On<Pointer<Click>>, mut color_filters: Query<&mut ColorFilters>| {
-                        toggle(&mut color_filters.get_mut(row_parent.get()).unwrap().0, color);
+                        toggle(&mut color_filters.get_mut(*row_parent).unwrap().0, color);
                     }),
-                ))
+                )
                 .component_signal(
-                    SignalBuilder::from_component_lazy(row_parent.clone())
-                        .dedupe()
+                    signal::from_component_changed_lazy(row_parent.clone())
                         .map_in(move |ColorFilters(filters)| filters.contains(&color))
                         .dedupe()
                         .map_true(|_: In<()>| outline()),
@@ -360,8 +351,8 @@ fn color_toggles(row_parent: LazyEntity) -> JonmoBuilder {
     )
 }
 
-fn button(text: &'static str, offset: f32) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn button(text: &'static str, offset: f32) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node {
             width: Val::Px((ITEM_SIZE / 2) as f32),
             height: Val::Px((ITEM_SIZE / 2) as f32),
@@ -383,9 +374,9 @@ fn button(text: &'static str, offset: f32) -> JonmoBuilder {
 #[derive(Component, Clone)]
 struct Index(usize);
 
-fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> JonmoBuilder {
+fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> jonmo::Builder {
     let row_parent = LazyEntity::new();
-    JonmoBuilder::from((
+    jonmo::Builder::from((
         Node {
             flex_direction: FlexDirection::Row,
             align_items: AlignItems::Center,
@@ -401,7 +392,7 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> Jon
     .child(
         button("-", -3.)
             .component_signal(index.map_in(|index| index.map(Index)))
-            .apply(on_click(
+            .observe(
                 |click: On<Pointer<Click>>,
                  rows: Res<Rows>,
                  indices: Query<&Index>,
@@ -410,10 +401,10 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> Jon
                         rows.0.write(&mut mutable_vec_datas).remove(index);
                     }
                 },
-            )),
+            ),
     )
     .child(
-        JonmoBuilder::from((Node {
+        jonmo::Builder::from((Node {
             flex_direction: FlexDirection::Row,
             width: Val::Px(108.),
             height: Val::Percent(100.),
@@ -426,14 +417,14 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> Jon
         .child(color_toggles(row_parent.clone())),
     )
     .child(
-        JonmoBuilder::from((Node {
+        jonmo::Builder::from((Node {
             flex_direction: FlexDirection::Row,
             align_items: AlignItems::Center,
             column_gap: Val::Px(GAP),
             ..default()
         },))
         .children_signal_vec(
-            SignalBuilder::from_lazy_entity(row_parent.clone())
+            signal::from_lazy_entity(row_parent.clone())
                 .has_component::<Sorted>()
                 .dedupe()
                 .switch_signal_vec(move |In(sorted)| {
@@ -445,8 +436,7 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> Jon
                     }
                 })
                 .filter_signal(clone!((row_parent) move | In((_, Data { number, .. })) | {
-                    SignalBuilder::from_component_lazy(row_parent.clone())
-                        .dedupe()
+                    signal::from_component_changed_lazy(row_parent.clone())
                         .map_in(move |number_filters: NumberFilters| {
                             number_filters.0.contains(&if number.is_multiple_of(2) {
                                 Parity::Even
@@ -457,14 +447,12 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> Jon
                         .dedupe()
                 }))
                 .filter_signal(clone!((row_parent) move | In((_, Data { shape, .. })) | {
-                    SignalBuilder::from_component_lazy(row_parent.clone())
-                        .dedupe()
+                    signal::from_component_changed_lazy(row_parent.clone())
                         .map_in(move |shape_filters: ShapeFilters| shape_filters.0.contains(&shape))
                         .dedupe()
                 }))
                 .filter_signal(clone!((row_parent) move | In((_, Data { color, .. })) | {
-                    SignalBuilder::from_component_lazy(row_parent.clone())
-                        .dedupe()
+                    signal::from_component_changed_lazy(row_parent.clone())
                         .map_in(move |color_filters: ColorFilters| color_filters.0.contains(&color))
                         .dedupe()
                 }))
@@ -487,8 +475,8 @@ enum Parity {
     Odd,
 }
 
-fn item(index: impl Signal<Item = Option<usize>>, Data { number, color, shape }: Data) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn item(index: impl Signal<Item = Option<usize>>, Data { number, color, shape }: Data) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node {
             height: Val::Px(ITEM_SIZE as f32),
             width: Val::Px(ITEM_SIZE as f32),
@@ -503,7 +491,7 @@ fn item(index: impl Signal<Item = Option<usize>>, Data { number, color, shape }:
         },
     ))
     .component_signal(index.map_in(|index| index.map(Index)))
-    .apply(on_click(
+    .observe(
         |click: On<Pointer<Click>>,
          datas: Res<Datas>,
          indices: Query<&Index>,
@@ -512,7 +500,7 @@ fn item(index: impl Signal<Item = Option<usize>>, Data { number, color, shape }:
                 datas.0.write(&mut mutable_vec_datas).remove(index);
             }
         },
-    ))
+    )
     .child((
         Node::default(),
         Text::new(number.to_string()),
diff --git a/examples/letters.rs b/examples/letters.rs
index cde6f4c..add99c0 100644
--- a/examples/letters.rs
+++ b/examples/letters.rs
@@ -20,12 +20,13 @@ fn main() {
         .map(|save_char| {
             (
                 save_char,
-                MutableBTreeMapBuilder::from(
-                    ROWS.iter()
-                        .flat_map(|row| row.chars().map(|letter| (letter, LetterData::default())))
-                        .collect::<BTreeMap<_, _>>(),
-                )
-                .spawn(app.world_mut()),
+                MutableBTreeMap::builder()
+                    .values(
+                        ROWS.iter()
+                            .flat_map(|row| row.chars().map(|letter| (letter, LetterData::default())))
+                            .collect::<BTreeMap<_, _>>(),
+                    )
+                    .spawn(app.world_mut()),
             )
         })
         .collect();
@@ -66,17 +67,17 @@ fn get_active_map(save_states: &SaveStates, active_save: ActiveSave) -> MutableB
 
 const LETTER_SIZE: f32 = 60.;
 
-fn ui_root() -> JonmoBuilder {
-    let active_save_signal = SignalBuilder::from_resource::<ActiveSave>().dedupe();
+fn ui_root() -> jonmo::Builder {
+    let active_save = signal::from_resource_changed::<ActiveSave>();
 
-    JonmoBuilder::from(Node {
+    jonmo::Builder::from(Node {
         height: Val::Percent(100.0),
         width: Val::Percent(100.0),
         justify_content: JustifyContent::Center,
         ..default()
     })
     .child(
-        JonmoBuilder::from(Node {
+        jonmo::Builder::from(Node {
             flex_direction: FlexDirection::Column,
             row_gap: Val::Px(GAP * 2.),
             padding: UiRect::all(Val::Px(GAP * 4.)),
@@ -85,19 +86,19 @@ fn ui_root() -> JonmoBuilder {
             ..default()
         })
         .child(
-            JonmoBuilder::from(Node {
+            jonmo::Builder::from(Node {
                 align_self: AlignSelf::Center,
                 width: Val::Percent(100.),
                 ..default()
             })
             .child(
-                JonmoBuilder::from(Node {
+                jonmo::Builder::from(Node {
                     flex_direction: FlexDirection::Row,
                     column_gap: Val::Px(GAP * 2.),
                     ..default()
                 })
-                .children(SAVE_CHARS.chars().map(clone!((active_save_signal) move |save_char| {
-                    save_card(save_char, active_save_signal.clone())
+                .children(SAVE_CHARS.chars().map(clone!((active_save) move |save_char| {
+                    save_card(save_char, active_save.clone())
                 }))),
             )
             .child(
@@ -107,7 +108,7 @@ fn ui_root() -> JonmoBuilder {
                         .insert((TextColor(BLUE), TextFont::from_font_size(LETTER_SIZE)))
                         .with_component::<Node>(|mut node| node.height = Val::Px(100.))
                         .component_signal(
-                            active_save_signal
+                            active_save
                                 .clone()
                                 .switch_signal_vec(move |In(active_save): In<ActiveSave>, save_states: Res<SaveStates>| {
                                     get_active_map(&save_states, active_save).signal_vec_entries()
@@ -122,15 +123,15 @@ fn ui_root() -> JonmoBuilder {
                 ),
             ),
         )
-        .children(ROWS.into_iter().map(clone!((active_save_signal) move |row| {
-            JonmoBuilder::from(Node {
+        .children(ROWS.into_iter().map(clone!((active_save) move |row| {
+            jonmo::Builder::from(Node {
                 flex_direction: FlexDirection::Row,
                 column_gap: Val::Px(GAP * 2.),
                 ..default()
             })
             .children(row.chars().map(
-                clone!((active_save_signal) move |l| {
-                    let letter_data = active_save_signal
+                clone!((active_save) move |l| {
+                    let letter_data = active_save
                         .clone()
                         .switch_signal_map(move |In(active_save): In<ActiveSave>, save_states: Res<SaveStates>| {
                             get_active_map(&save_states, active_save).signal_map()
@@ -146,7 +147,7 @@ fn ui_root() -> JonmoBuilder {
                     text_node()
                         .insert((TextColor(BLUE), TextFont::from_font_size(LETTER_SIZE)))
                         .component_signal(
-                            active_save_signal
+                            active_save
                                 .clone()
                                 .switch_signal_vec(move |In(active_save): In<ActiveSave>, save_states: Res<SaveStates>| {
                                     get_active_map(&save_states, active_save).signal_vec_entries()
@@ -167,8 +168,8 @@ fn ui_root() -> JonmoBuilder {
 
 const GAP: f32 = 5.;
 
-fn sum_container() -> JonmoBuilder {
-    JonmoBuilder::from(Node {
+fn sum_container() -> jonmo::Builder {
+    jonmo::Builder::from(Node {
         align_self: AlignSelf::Center,
         justify_content: JustifyContent::FlexEnd,
         flex_grow: 1.,
@@ -177,8 +178,8 @@ fn sum_container() -> JonmoBuilder {
     })
 }
 
-fn save_card(save_char: char, active_save_signal: impl Signal<Item = ActiveSave> + Clone) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn save_card(save_char: char, active_save_signal: impl Signal<Item = ActiveSave> + Clone) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node {
             width: Val::Px(100.),
             height: Val::Px(100.),
@@ -210,8 +211,8 @@ fn save_card(save_char: char, active_save_signal: impl Signal<Item = ActiveSave>
     )))
 }
 
-fn text_node() -> JonmoBuilder {
-    JonmoBuilder::from((
+fn text_node() -> jonmo::Builder {
+    jonmo::Builder::from((
         Node::default(),
         TextColor(Color::WHITE),
         TextLayout::new_with_justify(Justify::Center),
@@ -219,8 +220,8 @@ fn text_node() -> JonmoBuilder {
     ))
 }
 
-fn letter(letter: char, data: impl Signal<Item = LetterData> + Clone) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn letter(letter: char, data: impl Signal<Item = LetterData> + Clone) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node {
             flex_direction: FlexDirection::Column,
             row_gap: Val::Px(GAP * 2.),
diff --git a/examples/lifetimes.rs b/examples/lifetimes.rs
index 09125f2..daa83f7 100644
--- a/examples/lifetimes.rs
+++ b/examples/lifetimes.rs
@@ -27,7 +27,9 @@ fn main() {
     // We initialize it with two random colors.
     // It's wrapped in an `Arc<RwLock<...>>` internally, so cloning it is cheap
     // and allows multiple systems to access and modify the same data.
-    let colors = MutableVecBuilder::from([random_color(), random_color()]).spawn(world);
+    let colors = MutableVec::builder()
+        .values([random_color(), random_color()])
+        .spawn(world);
 
     app.add_plugins(examples_plugin)
         // 2. --- RESOURCE MANAGEMENT ---
@@ -78,9 +80,9 @@ struct Lifetime(f32);
 ///
 /// It takes a `SignalVec` of `Color`s as input. This is the reactive "pipe"
 /// that will drive the creation, destruction, and updating of child elements.
-fn ui_root(colors: impl SignalVec<Item = Color>) -> JonmoBuilder {
+fn ui_root(colors: impl SignalVec<Item = Color>) -> jonmo::Builder {
     // A standard vertical flexbox to hold our list items.
-    JonmoBuilder::from(Node {
+    jonmo::Builder::from(Node {
         height: Val::Percent(100.0),
         width: Val::Percent(100.0),
         flex_direction: FlexDirection::Column,
@@ -91,7 +93,7 @@ fn ui_root(colors: impl SignalVec<Item = Color>) -> JonmoBuilder {
     })
     // This is the core of the dynamic list.
     // `children_signal_vec` subscribes to a `SignalVec`. For each item in the
-    // vector, it spawns a child entity using the `JonmoBuilder` returned by the closure.
+    // vector, it spawns a child entity using the `jonmo::Builder` returned by the closure.
     // It handles all diffs automatically: `Push` creates a new child, `RemoveAt`
     // despawns one, `Move` reorders them, etc.
     .children_signal_vec(
@@ -103,7 +105,7 @@ fn ui_root(colors: impl SignalVec<Item = Color>) -> JonmoBuilder {
         colors.enumerate().map_in(|(index, color)| item(index.dedupe(), color)),
     )
     .child(
-        JonmoBuilder::from((
+        jonmo::Builder::from((
             Node {
                 height: Val::Px(40.),
                 width: Val::Px(100.),
@@ -132,7 +134,7 @@ fn ui_root(colors: impl SignalVec<Item = Color>) -> JonmoBuilder {
                 },
             );
         })
-        .child(JonmoBuilder::from((
+        .child(jonmo::Builder::from((
             Node::default(),
             Text::new("+"),
             TextColor(Color::WHITE),
@@ -147,13 +149,13 @@ fn ui_root(colors: impl SignalVec<Item = Color>) -> JonmoBuilder {
 #[derive(Component, Clone)]
 struct Index(usize);
 
-/// Constructs a `JonmoBuilder` for a single item in our list.
+/// Constructs a `jonmo::Builder` for a single item in our list.
 ///
 /// # Arguments
 /// * `index` - A `Signal<Item = Option<usize>>` that provides the current index of this item. This
 ///   signal is provided by the `.enumerate()` call in `ui_root`.
 /// * `color` - The `Color` for this specific item.
-fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> JonmoBuilder {
+fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> jonmo::Builder {
     // --- The LazyEntity Pattern ---
     // `LazyEntity` is a thread-safe, clone-able handle to an `Entity` that can be
     // created *before* the entity is spawned.
@@ -163,7 +165,7 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> Jonmo
     // fulfilled later.
     let lifetime_holder = LazyEntity::new();
 
-    JonmoBuilder::from((
+    jonmo::Builder::from((
         Node {
             height: Val::Px(40.0),
             width: Val::Px(350.0),
@@ -176,12 +178,12 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> Jonmo
         Lifetime::default(),
     ))
     // Here we fulfill the promise. `lazy_entity` will set the `Entity` id into the
-    // `lifetime_holder` once this `JonmoBuilder` is spawned into an actual entity.
+    // `lifetime_holder` once this `jonmo::Builder` is spawned into an actual entity.
     // Any signals that were created using `lifetime_holder` will now point to the correct entity.
     .lazy_entity(lifetime_holder.clone())
     .child({
         // The main info panel for the item.
-        JonmoBuilder::from((
+        jonmo::Builder::from((
             Node {
                 height: Val::Percent(100.),
                 width: Val::Percent(90.),
@@ -192,10 +194,10 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> Jonmo
             BackgroundColor(color),
         ))
         .child(
-            // This `JonmoBuilder` will hold the text. Bevy UI text is composed of `TextSection`s,
-            // which are children of a `Text` entity. We use `JonmoBuilder`'s child methods to
+            // This `jonmo::Builder` will hold the text. Bevy UI text is composed of `TextSection`s,
+            // which are children of a `Text` entity. We use `jonmo::Builder`'s child methods to
             // construct these sections reactively.
-            JonmoBuilder::from((
+            jonmo::Builder::from((
                 Node::default(),
                 // Start with a `Text` component with no sections. We'll add them as children.
                 Text::new(""),
@@ -206,7 +208,7 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> Jonmo
             .child((TextColor(Color::BLACK), TextSpan::new("item ")))
             // Child 2: A reactive text span for the index.
             .child(
-                JonmoBuilder::from(TextColor(Color::BLACK)).component_signal(
+                jonmo::Builder::from(TextColor(Color::BLACK)).component_signal(
                     // `component_signal` takes a signal and uses its output to insert/update a component.
                     index
                         .clone()
@@ -217,11 +219,11 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> Jonmo
             .child((TextColor(Color::BLACK), TextSpan::new(" | lifetime: ")))
             // Child 4: A reactive text span for the lifetime.
             .child(
-                JonmoBuilder::from(TextColor(Color::BLACK)).component_signal(
+                jonmo::Builder::from(TextColor(Color::BLACK)).component_signal(
                     // This is where the `LazyEntity` becomes powerful.
                     // We create a signal that reads a component from the entity that `lifetime_holder` will eventually
                     // point to.
-                    SignalBuilder::from_component_lazy(lifetime_holder)
+                    signal::from_component_changed_lazy(lifetime_holder)
                         // Map the `Lifetime` component to its inner `f32` value and round it.
                         .map_in(|Lifetime(lifetime)| lifetime.round())
                         // `dedupe` is a crucial optimization. It ensures the rest of the signal chain only runs
@@ -239,7 +241,7 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> Jonmo
     })
     // Add the "remove" button as a child of the item row.
     .child(
-        JonmoBuilder::from((
+        jonmo::Builder::from((
             Node {
                 height: Val::Percent(100.),
                 width: Val::Percent(10.),
@@ -275,7 +277,7 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> Jonmo
         // We use `component_signal` again to reactively insert the `Index` component,
         // driven by the same `index` signal we used for the display text.
         .component_signal(index.map_in(|index| index.map(Index)))
-        .child(JonmoBuilder::from((
+        .child(jonmo::Builder::from((
             Node::default(),
             Text::new("x"),
             TextColor(Color::WHITE),
diff --git a/examples/test.rs b/examples/test.rs
index 6ccfe77..8dc8cab 100644
--- a/examples/test.rs
+++ b/examples/test.rs
@@ -8,7 +8,7 @@ use jonmo::prelude::*;
 
 fn main() {
     let mut app = App::new();
-    let numbers = MutableVecBuilder::from([1, 2, 3, 4, 5]).spawn(app.world_mut());
+    let numbers = MutableVec::builder().values([1, 2, 3, 4, 5]).spawn(app.world_mut());
     app.add_plugins(examples_plugin)
         .insert_resource(Numbers(numbers.clone()))
         .add_systems(
@@ -32,12 +32,12 @@ struct Numbers(MutableVec<i32>);
 struct Lifetime(f32);
 
 #[rustfmt::skip]
-fn ui_root(numbers: MutableVec<i32>, world: &mut World) -> JonmoBuilder {
-    let list_a = MutableVecBuilder::from([1, 2, 3, 4, 5]).spawn(world).signal_vec();
-    let list_b = MutableVecBuilder::from([3, 4, 5]).spawn(world).signal_vec();
-    let map = MutableBTreeMapBuilder::from([(1, 2), (2, 3)]).spawn(world);
+fn ui_root(numbers: MutableVec<i32>, world: &mut World) -> jonmo::Builder {
+    let list_a = MutableVec::builder().values([1, 2, 3, 4, 5]).spawn(world).signal_vec();
+    let list_b = MutableVec::builder().values([3, 4, 5]).spawn(world).signal_vec();
+    let map = MutableBTreeMap::builder().values([(1, 2), (2, 3)]).spawn(world);
     // map.signal_map().
-    JonmoBuilder::from(Node {
+    jonmo::Builder::from(Node {
         height: Val::Percent(100.0),
         width: Val::Percent(100.0),
         flex_direction: FlexDirection::Column,
@@ -51,8 +51,8 @@ fn ui_root(numbers: MutableVec<i32>, world: &mut World) -> JonmoBuilder {
         // MutableVec::from([numbers.signal_vec(), numbers.signal_vec()]).signal_vec()
         numbers
             .signal_vec()
-            // SignalBuilder::from_system(|_: In<()>| 1)
-            // SignalBuilder::from_system(|_: In<()>, toggle: Res<ToggleFilter>| toggle.0)
+            // signal::from_system(|_: In<()>| 1)
+            // signal::from_system(|_: In<()>, toggle: Res<ToggleFilter>| toggle.0)
             // .dedupe()
             // .switch_signal_vec(move |In(toggle)| {
             //     if toggle {
@@ -66,12 +66,12 @@ fn ui_root(numbers: MutableVec<i32>, world: &mut World) -> JonmoBuilder {
             // .dedupe()
             // .to_signal_vec()
             .filter_signal(|In(n)| {
-                SignalBuilder::from_system(move |_: In<()>, toggle: Res<ToggleFilter>| {
+                signal::from_system(move |_: In<()>, toggle: Res<ToggleFilter>| {
                     n % 2 == if toggle.0 { 0 } else { 1 }
                 })
             })
             // .map_signal(|In(n): In<i32>| {
-            //     SignalBuilder::from_system(move |_: In<()>| n + 1).dedupe()
+            //     signal::from_system(move |_: In<()>| n + 1).dedupe()
             // })
             // .debug()
             // .map_in(|n: i32| -n)
@@ -89,7 +89,7 @@ fn ui_root(numbers: MutableVec<i32>, world: &mut World) -> JonmoBuilder {
             .map(|In(n)| item(n))
             // .intersperse_with(
             //     |index_signal: In<jonmo::signal::Dedupe<jonmo::signal::Source<Option<usize>>>>| {
-            //         JonmoBuilder::from(Node::default()).component_signal(
+            //         jonmo::Builder::from(Node::default()).component_signal(
             //             index_signal
             //                 .debug()
             //                 .map_in(|idx_opt| Text::new(format!("{}", idx_opt.unwrap_or(0)))),
@@ -102,8 +102,8 @@ fn ui_root(numbers: MutableVec<i32>, world: &mut World) -> JonmoBuilder {
 #[derive(Resource)]
 struct ToggleFilter(bool);
 
-fn item(number: i32) -> JonmoBuilder {
-    JonmoBuilder::from((
+fn item(number: i32) -> jonmo::Builder {
+    jonmo::Builder::from((
         Node {
             height: Val::Px(40.0),
             width: Val::Px(200.0),
@@ -113,7 +113,7 @@ fn item(number: i32) -> JonmoBuilder {
         },
         BackgroundColor(Color::WHITE),
     ))
-    .child(JonmoBuilder::from((
+    .child(jonmo::Builder::from((
         Node {
             height: Val::Percent(100.),
             width: Val::Percent(100.),
diff --git a/src/builder.rs b/src/builder.rs
index 7d75009..0832cf3 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1,23 +1,21 @@
 //! Reactive entity builder ported from [Dominator](https://github.com/Pauan/rust-dominator)'s [`DomBuilder`](https://docs.rs/dominator/latest/dominator/struct.DomBuilder.html).
 use super::{
     graph::{SignalHandle, SignalHandles},
-    signal::{Signal, SignalBuilder, SignalExt},
+    signal::{Signal, SignalExt},
     signal_map::{SignalMap, SignalMapExt},
     signal_vec::{SignalVec, SignalVecExt, VecDiff},
-    utils::{LazyEntity, SSs, ancestor_map},
+    utils::{LazyEntity, SSs},
 };
 use bevy_ecs::{
     component::Mutable,
     lifecycle::HookContext,
     prelude::*,
     system::{IntoObserverSystem, RunSystemOnce},
-    world::DeferredWorld,
+    world::{DeferredWorld, error::EntityMutableFetchError},
 };
 use bevy_log::warn;
-use bevy_platform::{
-    prelude::*,
-    sync::{Arc, Mutex},
-};
+use bevy_platform::prelude::*;
+use core::sync::atomic::{AtomicUsize, Ordering};
 
 // TODO: the fluent interface link breaks cargo fmt ??
 /// A thin facade over a Bevy [`Entity`] enabling the ergonomic registration of
@@ -34,34 +32,33 @@ use bevy_platform::{
 /// # `Clone` semantics
 ///
 /// This type implements [`Clone`] **only** to satisfy trait bounds required by signal combinators.
-/// **Cloning [`JonmoBuilder`]s at runtime is a bug.** See [`JonmoBuilder::clone`] for
-/// details.
+/// **Cloning [`jonmo::Builder`](Builder)s at runtime is a bug.** See
+/// [`jonmo::Builder::clone`](Builder::clone) for details.
 #[derive(Default)]
-pub struct JonmoBuilder {
+pub struct Builder {
     #[allow(clippy::type_complexity)]
-    on_spawns: Arc<Mutex<Vec<Box<dyn FnOnce(&mut World, Entity) + Send + Sync>>>>,
-    child_block_populations: Arc<Mutex<Vec<usize>>>,
+    on_spawns: Vec<Box<dyn FnOnce(&mut World, Entity) + Send + Sync>>,
+    /// Counter for assigning block indices during builder construction.
+    /// Each child/children/child_signal/children_signal_vec call gets a unique block index.
+    next_block: AtomicUsize,
 }
 
-impl Clone for JonmoBuilder {
+impl Clone for Builder {
     /// # Warning
     ///
     /// This clone implementation exists **only** to satisfy trait bounds required by signal
     /// combinators (e.g., [`SignalExt::map`], [`SignalVecExt::filter_map`]). **Cloning
-    /// [`JonmoBuilder`]s at runtime is a bug and will lead to unexpected behavior.**
+    /// [`jonmo::Builder`](Builder)s at runtime is a bug and will lead to unexpected behavior.**
     ///
-    /// Clones share internal on-spawn hooks via [`Arc`]. These hooks are one-shot ([`FnOnce`])
-    /// and are consumed when the builder is spawned. Spawning one clone will affect all other
-    /// clones.
-    ///
-    /// Use factory functions instead if you need reusable UI templates:
+    /// Clones produce an empty builder with no on-spawn hooks. Use factory functions instead
+    /// if you need reusable UI templates:
     ///
     /// ```
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// fn my_widget(label: &str) -> JonmoBuilder {
-    ///     JonmoBuilder::new().insert(Name::new(label.to_string()))
+    /// fn my_widget(label: &str) -> jonmo::Builder {
+    ///     jonmo::Builder::new().insert(Name::new(label.to_string()))
     ///     // ... other configuration
     /// }
     ///
@@ -73,35 +70,34 @@ impl Clone for JonmoBuilder {
     #[track_caller]
     fn clone(&self) -> Self {
         warn!(
-            "Cloning `JonmoBuilder` at {} is a bug! `JonmoBuilder`'s `Clone` shares internal on-spawn \
-             hook queues via `Arc`. These hooks are one-shot (`FnOnce`) and are consumed on spawn. \
-             Spawning one clone will affect all other clones. Use factory functions instead if you \
-             need reusable UI templates.",
+            "Cloning `jonmo::Builder` at {} is a bug! Use a factory function instead.",
             core::panic::Location::caller()
         );
 
-        Self {
-            on_spawns: self.on_spawns.clone(),
-            child_block_populations: self.child_block_populations.clone(),
-        }
+        Self::default()
     }
 }
 
-impl<T: Bundle> From<T> for JonmoBuilder {
+impl<T: Bundle> From<T> for Builder {
     fn from(bundle: T) -> Self {
         Self::new().insert(bundle)
     }
 }
 
-impl JonmoBuilder {
+/// Component that tracks the population of each child block for offset calculation.
+/// Used internally by reactive child methods.
+#[derive(Component, Default)]
+struct ChildBlockPopulations(Vec<usize>);
+
+impl Builder {
     #[allow(missing_docs)]
     pub fn new() -> Self {
         Self::default()
     }
 
     /// Run a function with mutable access to the [`World`] and this builder's [`Entity`].
-    pub fn on_spawn(self, on_spawn: impl FnOnce(&mut World, Entity) + SSs) -> Self {
-        self.on_spawns.lock().unwrap().push(Box::new(on_spawn));
+    pub fn on_spawn(mut self, on_spawn: impl FnOnce(&mut World, Entity) + SSs) -> Self {
+        self.on_spawns.push(Box::new(on_spawn));
         self
     }
 
@@ -135,18 +131,18 @@ impl JonmoBuilder {
     ///     value: i32,
     /// }
     ///
-    /// let my_signal_task = SignalBuilder::from_resource::<MyResource>()
+    /// let my_signal_task = signal::from_resource::<MyResource>()
     ///     .map_in(|r: MyResource| println!("{}", r.value))
     ///     .task();
     ///
     /// let mut world = World::new();
-    /// let my_mutable_vec = MutableVecBuilder::from([1, 2, 3]).spawn(&mut world);
+    /// let my_mutable_vec = MutableVec::builder().values([1, 2, 3]).spawn(&mut world);
     /// let my_signal_vec_task = my_mutable_vec
     ///     .signal_vec()
     ///     .map_in(|item: i32| println!("{}", item))
     ///     .task();
     ///
-    /// JonmoBuilder::new().hold_tasks([my_signal_task, my_signal_vec_task]);
+    /// jonmo::Builder::new().hold_tasks([my_signal_task, my_signal_vec_task]);
     /// ```
     pub fn hold_tasks(self, tasks: impl IntoIterator<Item = Box<dyn SignalTask>> + SSs) -> Self {
         self.on_spawn(move |world, entity| {
@@ -158,9 +154,7 @@ impl JonmoBuilder {
     /// Run a function with this builder's [`EntityWorldMut`].
     pub fn with_entity(self, f: impl FnOnce(EntityWorldMut) + SSs) -> Self {
         self.on_spawn(move |world, entity| {
-            if let Ok(entity) = world.get_entity_mut(entity) {
-                f(entity);
-            }
+            f(world.entity_mut(entity));
         })
     }
 
@@ -187,9 +181,7 @@ impl JonmoBuilder {
         observer: impl IntoObserverSystem<E, B, Marker> + Sync,
     ) -> Self {
         self.on_spawn(|world, entity| {
-            if let Ok(mut entity) = world.get_entity_mut(entity) {
-                entity.observe(observer);
-            }
+            world.entity_mut(entity).observe(observer);
         })
     }
 
@@ -197,12 +189,11 @@ impl JonmoBuilder {
     /// [`DeferredWorld`] and this builder's [`Entity`].
     pub fn on_despawn(self, on_despawn: impl FnOnce(&mut DeferredWorld, Entity) + Send + Sync + 'static) -> Self {
         self.on_spawn(|world, entity| {
-            if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
-                if let Some(mut on_despawn_component) = entity_mut.get_mut::<OnDespawnCallbacks>() {
-                    on_despawn_component.0.push(Box::new(on_despawn));
-                } else {
-                    entity_mut.insert(OnDespawnCallbacks(vec![Box::new(on_despawn)]));
-                }
+            let mut entity_mut = world.entity_mut(entity);
+            if let Some(mut on_despawn_component) = entity_mut.get_mut::<OnDespawnCallbacks>() {
+                on_despawn_component.0.push(Box::new(on_despawn));
+            } else {
+                entity_mut.insert(OnDespawnCallbacks(vec![Box::new(on_despawn)]));
             }
         })
     }
@@ -242,9 +233,7 @@ impl JonmoBuilder {
         F: FnMut(EntityWorldMut, I) + SSs,
     {
         self.on_signal(signal, move |In((entity, value)), world: &mut World| {
-            if let Ok(entity) = world.get_entity_mut(entity) {
-                f(entity, value)
-            }
+            f(world.entity_mut(entity), value)
         })
     }
 
@@ -273,133 +262,6 @@ impl JonmoBuilder {
         self.on_spawn(on_spawn)
     }
 
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`] and returns a
-    /// [`Signal`].
-    ///
-    /// The resulting [`Signal`] will be automatically cleaned up when the [`Entity`] is despawned.
-    pub fn signal_from_entity<S, F>(self, f: F) -> Self
-    where
-        S: Signal,
-        F: FnOnce(super::signal::Source<Entity>) -> S + SSs,
-    {
-        let on_spawn = move |world: &mut World, entity: Entity| {
-            let handle = Signal::register_signal(f(SignalBuilder::from_entity(entity)), world);
-            add_handles(world, entity, [handle]);
-        };
-        self.on_spawn(on_spawn)
-    }
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s `C`
-    /// [`Component`] and returns a [`Signal`]; if this builder's [`Entity`] does not have a `C`
-    /// [`Component`], the [`Signal`] chain will terminate for the frame.
-    ///
-    /// The resulting [`Signal`] will be automatically cleaned up when the [`Entity`] is despawned.
-    pub fn signal_from_component<C, S, F>(self, f: F) -> Self
-    where
-        C: Component + Clone,
-        S: Signal,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, C>) -> S + SSs,
-    {
-        self.signal_from_entity(|signal| {
-            f(signal.map(|In(entity): In<Entity>, components: Query<&C>| components.get(entity).ok().cloned()))
-        })
-    }
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s `C`
-    /// [`Component`] wrapped in an [`Option`] and returns a [`Signal`]; if this builder's
-    /// [`Entity`] does not have a `C` [`Component`], the [`Signal`] will output [`None`] and
-    /// continue propagation.
-    ///
-    /// The resulting [`Signal`] will be automatically cleaned up when the [`Entity`] is despawned.
-    pub fn signal_from_component_option<C, S, F>(self, f: F) -> Self
-    where
-        C: Component + Clone,
-        S: Signal,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, Option<C>>) -> S + SSs,
-    {
-        self.signal_from_entity(|signal| {
-            f(signal.map(|In(entity): In<Entity>, components: Query<&C>| Some(components.get(entity).ok().cloned())))
-        })
-    }
-
-    // Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s `C`
-    /// [`Component`] on frames it has [`Changed`] and returns a [`Signal`]; if this builder's
-    /// [`Entity`] does not have a `C` [`Component`], the [`Signal`] chain will terminate for
-    /// the frame.
-    ///
-    /// The resulting [`Signal`] will be automatically cleaned up when the [`Entity`] is despawned.
-    pub fn signal_from_component_changed<C, S, F>(self, f: F) -> Self
-    where
-        C: Component + Clone,
-        S: Signal,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, C>) -> S + SSs,
-    {
-        self.signal_from_entity(|signal| {
-            f(signal
-                .map(|In(entity): In<Entity>, components: Query<&C, Changed<C>>| components.get(entity).ok().cloned()))
-        })
-    }
-
-    // TODO: ehh these could be useful but one should really just use LazyEntity ...
-    /* pub fn signal_from_ancestor_find<S, F, P, M>(self, f: F, predicate: P) -> Self
-    where
-        S: Signal,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, Option<Entity>>) -> S + SSs,
-        P: IntoSystem<In<Entity>, bool, M> + SSs
-    {
-        let system = Arc::new(OnceLock::new());
-        self.on_spawn(clone!((system) move|world, entity| {
-            let system_id = world.register_system(predicate);
-            world.entity_mut(entity).add_child(system_id.entity());
-            let _ =system.set(system_id);
-        }))
-        .signal_from_entity(move |signal| {
-            f(signal.map(move |In(entity): In<Entity>, world: &mut World| {
-                let mutancestors = SystemState::<Query<&ChildOf>>::new(world);
-                let ancestors = ancestors.get(world);
-                let ancestors = ancestors.iter_ancestors(entity).collect::<Vec<_>>();
-                ancestors.into_iter().find(|&ancestor| {
-                    world.run_system_with(system.get().copied().unwrap(), ancestor) .ok().unwrap_or(false)
-                })
-            }))
-        })
-    }
-
-    pub fn signal_from_ancestor_with_component<C, S, F>(self, f: F) -> Self
-    where
-        C: Component,
-        S: Signal,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, Option<Entity>>)-> S + SSs
-    {
-        self.signal_from_ancestor_find(f, |In(entity), components:Query<&C>| components.contains(entity))
-    } */
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s
-    /// `generations`-th generation ancestor if it exists (terminating for the frame otherwise) and
-    /// returns a [`Signal`]. Passing `0` to `generations` will output this builder's [`Entity`]
-    /// itself.
-    ///
-    /// The resulting [`Signal`] will be automatically cleaned up when the [`Entity`] is despawned.
-    pub fn signal_from_ancestor<S, F>(self, generations: usize, f: F) -> Self
-    where
-        S: Signal,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, Entity>) -> S + SSs,
-    {
-        self.signal_from_entity(move |signal| f(signal.map(ancestor_map(generations))))
-    }
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's parent's [`Entity`] if
-    /// it exists (terminating for the frame otherwise) and returns a [`Signal`].
-    ///
-    /// The resulting [`Signal`] will be automatically cleaned up when the [`Entity`] is despawned.
-    pub fn signal_from_parent<S, F>(self, f: F) -> Self
-    where
-        S: Signal,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, Entity>) -> S + SSs,
-    {
-        self.signal_from_ancestor(1, f)
-    }
-
     /// Reactively set this builder's [`Entity`]'s `C` [`Component`] with a [`Signal`] that outputs
     /// an [`Option`]al `C`; if the [`Signal`] outputs [`None`], the `C` [`Component`] is removed.
     pub fn component_signal<C, S>(self, signal: S) -> Self
@@ -410,187 +272,65 @@ impl JonmoBuilder {
         self.on_signal(
             signal,
             move |In((entity, component_option)): In<(Entity, Option<C>)>, world: &mut World| {
-                if let Ok(mut entity) = world.get_entity_mut(entity) {
-                    if let Some(component) = component_option {
-                        entity.insert(component);
-                    } else {
-                        entity.remove::<C>();
-                    }
+                let mut entity = world.entity_mut(entity);
+                if let Some(component) = component_option {
+                    entity.insert(component);
+                } else {
+                    entity.remove::<C>();
                 }
             },
         )
     }
 
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`] and returns a
-    /// [`Signal`] that outputs an [`Option`]al `C`; this resulting [`Signal`] reactively sets this
-    /// builder's [`Entity`]'s `C` [`Component`]; if the [`Signal`] outputs [`None`], the `C`
-    /// [`Component`] is removed.
-    pub fn component_signal_from_entity<C, S, F>(self, f: F) -> Self
-    where
-        C: Component,
-        S: Signal<Item = Option<C>>,
-        F: FnOnce(super::signal::Source<Entity>) -> S + SSs,
-    {
-        let entity = LazyEntity::new();
-        self.lazy_entity(entity.clone()).signal_from_entity(move |signal| {
-            f(signal).map(move |In(component_option): In<Option<C>>, world: &mut World| {
-                if let Ok(mut entity) = world.get_entity_mut(entity.get()) {
-                    if let Some(component) = component_option {
-                        entity.insert(component);
-                    } else {
-                        entity.remove::<C>();
-                    }
-                }
-            })
-        })
-    }
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s
-    /// `generations`-th generation ancestor's [`Entity`] if it exists (terminating for the frame
-    /// otherwise) and returns a [`Signal`] that outputs an [`Option`]al `C`; this resulting
-    /// [`Signal`] reactively sets this builder's [`Entity`]'s `C` [`Component`]; if the
-    /// [`Signal`] outputs [`None`], the `C` [`Component`] is removed.
-    pub fn component_signal_from_ancestor<C, S, F>(self, generations: usize, f: F) -> Self
-    where
-        C: Component,
-        S: Signal<Item = Option<C>>,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, Entity>) -> S + SSs,
-    {
-        let entity = LazyEntity::new();
-        self.lazy_entity(entity.clone()).signal_from_entity(move |signal| {
-            f(signal.map(ancestor_map(generations))).map(
-                move |In(component_option): In<Option<C>>, world: &mut World| {
-                    if let Ok(mut entity) = world.get_entity_mut(entity.get()) {
-                        if let Some(component) = component_option {
-                            entity.insert(component);
-                        } else {
-                            entity.remove::<C>();
-                        }
-                    }
-                },
-            )
-        })
-    }
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s parent
-    /// [`Entity`] if it exists (terminating for the frame otherwise) and returns a [`Signal`] that
-    /// outputs an [`Option`]al `C`; this resulting [`Signal`] reactively sets this builder's
-    /// [`Entity`]'s `C` [`Component`]; if the [`Signal`] outputs [`None`], the `C`
-    /// [`Component`] is removed.
-    pub fn component_signal_from_parent<C, S, F>(self, f: F) -> Self
-    where
-        C: Component,
-        S: Signal<Item = Option<C>>,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, Entity>) -> S + SSs,
-    {
-        self.component_signal_from_ancestor(1, f)
-    }
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s `C`
-    /// [`Component`] and returns a [`Signal`] that outputs an [`Option`]al `C`; this resulting
-    /// [`Signal`] reactively sets this builder's [`Entity`]'s `C` [`Component`]; if the [`Signal`]
-    /// outputs [`None`], the `C` [`Component`] is removed. If this builder's [`Entity`] does not
-    /// have a `C` [`Component`], the [`Signal`]'s execution path will terminate for the frame.
-    pub fn component_signal_from_component<I, O, S, F>(self, f: F) -> Self
-    where
-        I: Component + Clone,
-        O: Component,
-        S: Signal<Item = Option<O>> + SSs,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, I>) -> S + SSs,
-    {
-        self.component_signal_from_entity(|signal| {
-            f(signal.map(|In(entity): In<Entity>, components: Query<&I>| components.get(entity).ok().cloned()))
-        })
-    }
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s `C`
-    /// [`Component`] and returns a [`Signal`] that outputs an [`Option`]al `C`; this resulting
-    /// [`Signal`] reactively sets this builder's [`Entity`]'s `C` [`Component`]; if the [`Signal`]
-    /// outputs [`None`], the `C` [`Component`] is removed. If this builder's [`Entity`] does not
-    /// have a `C` [`Component`], the input [`Signal`] will output [`None`] and continue
-    /// propagation.
-    pub fn component_signal_from_component_option<I, O, S, F>(self, f: F) -> Self
-    where
-        I: Component + Clone,
-        O: Component,
-        S: Signal<Item = Option<O>> + SSs,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, Option<I>>) -> S + SSs,
-    {
-        self.component_signal_from_entity(|signal| {
-            f(signal.map(|In(entity): In<Entity>, components: Query<&I>| Some(components.get(entity).ok().cloned())))
-        })
-    }
-
-    /// Run a function that takes a [`Signal`] which outputs this builder's [`Entity`]'s `C`
-    /// [`Component`] on frames it has [`Changed`] and returns a [`Signal`] that outputs an
-    /// [`Option`]al `O`; this resulting [`Signal`] reactively sets this builder's [`Entity`]'s `O`
-    /// [`Component`]; if the [`Signal`] outputs [`None`], the `O` [`Component`] is removed. If this
-    /// builder's [`Entity`] does not have a `C` [`Component`] or it has not [`Changed`], the
-    /// [`Signal`]'s execution path will terminate for the frame.
-    pub fn component_signal_from_component_changed<I, O, S, F>(self, f: F) -> Self
-    where
-        I: Component + Clone,
-        O: Component,
-        S: Signal<Item = Option<O>> + SSs,
-        F: FnOnce(super::signal::Map<super::signal::Source<Entity>, I>) -> S + SSs,
-    {
-        self.component_signal_from_entity(|signal| {
-            f(signal
-                .map(|In(entity): In<Entity>, components: Query<&I, Changed<I>>| components.get(entity).ok().cloned()))
-        })
-    }
-
     /// Declare a static child.
-    pub fn child(self, child: impl Into<JonmoBuilder>) -> Self {
-        let block = self.child_block_populations.lock().unwrap().len();
-        self.child_block_populations.lock().unwrap().push(1);
-        let offset = offset(block, &self.child_block_populations.lock().unwrap());
+    pub fn child(self, child: impl Into<Builder>) -> Self {
+        let block = self.next_block.fetch_add(1, Ordering::Relaxed);
         let child = child.into();
         let on_spawn = move |world: &mut World, parent| {
             let child_entity = world.spawn_empty().id();
-            if let Ok(ref mut parent) = world.get_entity_mut(parent) {
-                // need to call like this to avoid type ambiguity
-                EntityWorldMut::insert_children(parent, offset, &[child_entity]);
-                child.spawn_on_entity(world, child_entity);
-            } else if let Ok(child) = world.get_entity_mut(child_entity) {
-                child.despawn();
+            // Ensure the populations vec is large enough and set this block's population
+            let mut pops = world.get_mut::<ChildBlockPopulations>(parent).unwrap();
+            if pops.0.len() <= block {
+                pops.0.resize(block + 1, 0);
             }
+            pops.0[block] = 1;
+            let insert_offset = offset(block, &pops.0);
+            // need to call like this to avoid type ambiguity
+            EntityWorldMut::insert_children(&mut world.entity_mut(parent), insert_offset, &[child_entity]);
+            child.spawn_on_entity(world, child_entity).unwrap();
         };
         self.on_spawn(on_spawn)
     }
 
     /// Declare a reactive child. When the [`Signal`] outputs [`None`], the child is removed.
-    pub fn child_signal(self, child_option: impl Signal<Item = Option<JonmoBuilder>>) -> Self {
-        let block = self.child_block_populations.lock().unwrap().len();
-        self.child_block_populations.lock().unwrap().push(0);
-        let child_block_populations = self.child_block_populations.clone();
+    pub fn child_signal(self, child_option: impl Signal<Item = Option<Builder>>) -> Self {
+        let block = self.next_block.fetch_add(1, Ordering::Relaxed);
         let on_spawn = move |world: &mut World, parent: Entity| {
-            let system = move |In(child_option): In<Option<JonmoBuilder>>,
+            // Initialize this block's population to 0
+            let mut pops = world.get_mut::<ChildBlockPopulations>(parent).unwrap();
+            if pops.0.len() <= block {
+                pops.0.resize(block + 1, 0);
+            }
+
+            let system = move |In(child_option): In<Option<Builder>>,
                                world: &mut World,
                                mut existing_child_option: Local<Option<Entity>>| {
                 if let Some(child) = child_option {
-                    if let Some(existing_child) = existing_child_option.take()
-                        && let Ok(entity) = world.get_entity_mut(existing_child)
-                    {
-                        entity.despawn();
+                    if let Some(existing_child) = existing_child_option.take() {
+                        world.entity_mut(existing_child).despawn();
                     }
                     let child_entity = world.spawn_empty().id();
-                    if let Ok(mut parent) = world.get_entity_mut(parent) {
-                        let offset = offset(block, &child_block_populations.lock().unwrap());
-                        parent.insert_children(offset, &[child_entity]);
-                        child.spawn_on_entity(world, child_entity);
-                        *existing_child_option = Some(child_entity);
-                    } else if let Ok(child) = world.get_entity_mut(child_entity) {
-                        child.despawn();
-                    }
-                    child_block_populations.lock().unwrap()[block] = 1;
+                    let pops = world.get::<ChildBlockPopulations>(parent).unwrap();
+                    let insert_offset = offset(block, &pops.0);
+                    world.entity_mut(parent).insert_children(insert_offset, &[child_entity]);
+                    child.spawn_on_entity(world, child_entity).unwrap();
+                    *existing_child_option = Some(child_entity);
+                    world.get_mut::<ChildBlockPopulations>(parent).unwrap().0[block] = 1;
                 } else {
-                    if let Some(existing_child) = existing_child_option.take()
-                        && let Ok(entity) = world.get_entity_mut(existing_child)
-                    {
-                        entity.despawn();
+                    if let Some(existing_child) = existing_child_option.take() {
+                        world.entity_mut(existing_child).despawn();
                     }
-                    child_block_populations.lock().unwrap()[block] = 0;
+                    world.get_mut::<ChildBlockPopulations>(parent).unwrap().0[block] = 0;
                 }
             };
             let handle = child_option.map(system).register(world);
@@ -600,120 +340,96 @@ impl JonmoBuilder {
     }
 
     /// Declare static children.
-    pub fn children(self, children: impl IntoIterator<Item = impl Into<JonmoBuilder>> + Send + 'static) -> Self {
-        let block = self.child_block_populations.lock().unwrap().len();
-        let children_vec: Vec<JonmoBuilder> = children.into_iter().map(Into::into).collect();
+    pub fn children(self, children: impl IntoIterator<Item = impl Into<Builder>> + Send + 'static) -> Self {
+        let block = self.next_block.fetch_add(1, Ordering::Relaxed);
+        let children_vec: Vec<Builder> = children.into_iter().map(Into::into).collect();
         let population = children_vec.len();
-        self.child_block_populations.lock().unwrap().push(population);
-        let child_block_populations = self.child_block_populations.clone();
         let on_spawn = move |world: &mut World, parent: Entity| {
             let mut children_entities = Vec::with_capacity(children_vec.len());
             for _ in 0..children_vec.len() {
                 children_entities.push(world.spawn_empty().id());
             }
-            if let Ok(mut parent) = world.get_entity_mut(parent) {
-                let offset = offset(block, &child_block_populations.lock().unwrap());
-                parent.insert_children(offset, &children_entities);
-                for (child, child_entity) in children_vec.into_iter().zip(children_entities.iter().copied()) {
-                    child.spawn_on_entity(world, child_entity);
-                }
-            } else {
-                for child_entity in children_entities {
-                    if let Ok(child) = world.get_entity_mut(child_entity) {
-                        child.despawn(); // removes from parent
-                    }
-                }
+            // Set this block's population
+            let mut pops = world.get_mut::<ChildBlockPopulations>(parent).unwrap();
+            if pops.0.len() <= block {
+                pops.0.resize(block + 1, 0);
+            }
+            pops.0[block] = population;
+            let insert_offset = offset(block, &pops.0);
+            world
+                .entity_mut(parent)
+                .insert_children(insert_offset, &children_entities);
+            for (child, child_entity) in children_vec.into_iter().zip(children_entities.iter().copied()) {
+                child.spawn_on_entity(world, child_entity).unwrap();
             }
         };
         self.on_spawn(on_spawn)
     }
 
     /// Declare reactive children.
-    pub fn children_signal_vec(self, children_signal_vec: impl SignalVec<Item = JonmoBuilder>) -> Self {
-        let block = self.child_block_populations.lock().unwrap().len();
-        self.child_block_populations.lock().unwrap().push(0);
-        let child_block_populations = self.child_block_populations.clone();
+    pub fn children_signal_vec(self, children_signal_vec: impl SignalVec<Item = Builder>) -> Self {
+        let block = self.next_block.fetch_add(1, Ordering::Relaxed);
         let on_spawn = move |world: &mut World, parent: Entity| {
-            let system = move |In(diffs): In<Vec<VecDiff<JonmoBuilder>>>,
+            // Initialize this block's population to 0
+            let mut pops = world.get_mut::<ChildBlockPopulations>(parent).unwrap();
+            if pops.0.len() <= block {
+                pops.0.resize(block + 1, 0);
+            }
+
+            let system = move |In(diffs): In<Vec<VecDiff<Builder>>>,
                                world: &mut World,
                                mut children_entities: Local<Vec<Entity>>| {
                 for diff in diffs {
                     match diff {
                         VecDiff::Replace { values: children } => {
                             for child_entity in children_entities.drain(..) {
-                                if let Ok(child) = world.get_entity_mut(child_entity) {
-                                    child.despawn();
-                                }
+                                world.entity_mut(child_entity).despawn();
                             }
                             *children_entities = children.iter().map(|_| world.spawn_empty().id()).collect();
-                            if let Ok(mut parent) = world.get_entity_mut(parent) {
-                                let offset = offset(block, &child_block_populations.lock().unwrap());
-                                parent.insert_children(offset, &children_entities);
-                                for (child, child_entity) in children.into_iter().zip(children_entities.iter().copied())
-                                {
-                                    child.spawn_on_entity(world, child_entity);
-                                }
-                                child_block_populations.lock().unwrap()[block] = children_entities.len();
+                            let pops = world.get::<ChildBlockPopulations>(parent).unwrap();
+                            let insert_offset = offset(block, &pops.0);
+                            world
+                                .entity_mut(parent)
+                                .insert_children(insert_offset, &children_entities);
+                            for (child, child_entity) in children.into_iter().zip(children_entities.iter().copied()) {
+                                child.spawn_on_entity(world, child_entity).unwrap();
                             }
+                            world.get_mut::<ChildBlockPopulations>(parent).unwrap().0[block] = children_entities.len();
                         }
                         VecDiff::InsertAt { index, value: child } => {
                             let child_entity = world.spawn_empty().id();
-                            if let Ok(mut parent) = world.get_entity_mut(parent) {
-                                let offset = offset(block, &child_block_populations.lock().unwrap());
-                                parent.insert_children(offset + index, &[child_entity]);
-                                child.spawn_on_entity(world, child_entity);
-                                children_entities.insert(index, child_entity);
-                                child_block_populations.lock().unwrap()[block] = children_entities.len();
-                            } else {
-                                // Parent despawned during child insertion
-                                if let Ok(child) = world.get_entity_mut(child_entity) {
-                                    child.despawn();
-                                }
-                            }
+                            let pops = world.get::<ChildBlockPopulations>(parent).unwrap();
+                            let insert_offset = offset(block, &pops.0);
+                            world
+                                .entity_mut(parent)
+                                .insert_children(insert_offset + index, &[child_entity]);
+                            child.spawn_on_entity(world, child_entity).unwrap();
+                            children_entities.insert(index, child_entity);
+                            world.get_mut::<ChildBlockPopulations>(parent).unwrap().0[block] = children_entities.len();
                         }
                         VecDiff::Push { value: child } => {
                             let child_entity = world.spawn_empty().id();
-                            let mut push_child_entity = false;
-                            {
-                                if let Ok(mut parent) = world.get_entity_mut(parent) {
-                                    let offset = offset(block, &child_block_populations.lock().unwrap());
-                                    parent.insert_children(offset + children_entities.len(), &[child_entity]);
-                                    child.spawn_on_entity(world, child_entity);
-                                    push_child_entity = true;
-                                    child_block_populations.lock().unwrap()[block] = children_entities.len();
-                                } else {
-                                    // parent despawned during child spawning
-                                    if let Ok(child) = world.get_entity_mut(child_entity) {
-                                        child.despawn();
-                                    }
-                                }
-                            }
-                            if push_child_entity {
-                                children_entities.push(child_entity);
-                            }
+                            let pops = world.get::<ChildBlockPopulations>(parent).unwrap();
+                            let insert_offset = offset(block, &pops.0);
+                            world
+                                .entity_mut(parent)
+                                .insert_children(insert_offset + children_entities.len(), &[child_entity]);
+                            child.spawn_on_entity(world, child_entity).unwrap();
+                            children_entities.push(child_entity);
+                            world.get_mut::<ChildBlockPopulations>(parent).unwrap().0[block] = children_entities.len();
                         }
                         VecDiff::UpdateAt { index, value: node } => {
-                            if let Some(existing_child) = children_entities.get(index).copied()
-                                && let Ok(child) = world.get_entity_mut(existing_child)
-                            {
-                                child.despawn(); // removes from parent
+                            if let Some(existing_child) = children_entities.get(index).copied() {
+                                world.entity_mut(existing_child).despawn(); // removes from parent
                             }
                             let child_entity = world.spawn_empty().id();
-                            let mut set_child_entity = false;
-                            if let Ok(mut parent) = world.get_entity_mut(parent) {
-                                set_child_entity = true;
-                                let offset = offset(block, &child_block_populations.lock().unwrap());
-                                parent.insert_children(offset + index, &[child_entity]);
-                                node.spawn_on_entity(world, child_entity);
-                            } else {
-                                // parent despawned during child spawning
-                                if let Ok(child) = world.get_entity_mut(child_entity) {
-                                    child.despawn();
-                                }
-                            }
-                            if set_child_entity {
-                                children_entities[index] = child_entity;
-                            }
+                            let pops = world.get::<ChildBlockPopulations>(parent).unwrap();
+                            let insert_offset = offset(block, &pops.0);
+                            world
+                                .entity_mut(parent)
+                                .insert_children(insert_offset + index, &[child_entity]);
+                            node.spawn_on_entity(world, child_entity).unwrap();
+                            children_entities[index] = child_entity;
                         }
                         VecDiff::Move { old_index, new_index } => {
                             // First, update our local tracker to match the new logical order. This is the
@@ -722,42 +438,40 @@ impl JonmoBuilder {
                             children_entities.insert(new_index, moved_entity);
 
                             // Now, apply the same reordering to the actual parent entity in the world.
-                            if let Ok(mut parent) = world.get_entity_mut(parent) {
-                                // Bevy's `remove_children` finds the entity and removes it from its
-                                // current position, correctly shifting subsequent children.
-                                parent.remove_children(&[moved_entity]);
-
-                                // The new insertion index must be calculated with the offset from any
-                                // preceding static children.
-                                let offset = offset(block, &child_block_populations.lock().unwrap());
-                                parent.insert_children(offset + new_index, &[moved_entity]);
-                            }
+                            let mut parent = world.entity_mut(parent);
+                            // Bevy's `remove_children` finds the entity and removes it from its
+                            // current position, correctly shifting subsequent children.
+                            parent.remove_children(&[moved_entity]);
+                            let parent_entity = parent.id();
+
+                            // The new insertion index must be calculated with the offset from any
+                            // preceding static children.
+                            let pops = world.get::<ChildBlockPopulations>(parent_entity).unwrap();
+                            let insert_offset = offset(block, &pops.0);
+                            world
+                                .entity_mut(parent_entity)
+                                .insert_children(insert_offset + new_index, &[moved_entity]);
                         }
                         VecDiff::RemoveAt { index } => {
                             if let Some(existing_child) = children_entities.get(index).copied() {
-                                if let Ok(child) = world.get_entity_mut(existing_child) {
-                                    // removes from parent
-                                    child.despawn();
-                                }
+                                world.entity_mut(existing_child).despawn();
                                 children_entities.remove(index);
-                                child_block_populations.lock().unwrap()[block] = children_entities.len();
+                                world.get_mut::<ChildBlockPopulations>(parent).unwrap().0[block] =
+                                    children_entities.len();
                             }
                         }
                         VecDiff::Pop => {
                             if let Some(child_entity) = children_entities.pop() {
-                                if let Ok(child) = world.get_entity_mut(child_entity) {
-                                    child.despawn();
-                                }
-                                child_block_populations.lock().unwrap()[block] = children_entities.len();
+                                world.entity_mut(child_entity).despawn();
+                                world.get_mut::<ChildBlockPopulations>(parent).unwrap().0[block] =
+                                    children_entities.len();
                             }
                         }
                         VecDiff::Clear => {
                             for child_entity in children_entities.drain(..) {
-                                if let Ok(child) = world.get_entity_mut(child_entity) {
-                                    child.despawn();
-                                }
+                                world.entity_mut(child_entity).despawn();
                             }
-                            child_block_populations.lock().unwrap()[block] = children_entities.len();
+                            world.get_mut::<ChildBlockPopulations>(parent).unwrap().0[block] = children_entities.len();
                         }
                     }
                 }
@@ -769,27 +483,32 @@ impl JonmoBuilder {
     }
 
     /// Spawn this builder on an existing [`Entity`].
-    pub fn spawn_on_entity(self, world: &mut World, entity: Entity) {
-        if let Ok(mut entity) = world.get_entity_mut(entity) {
-            let id = entity.id();
-            entity.insert(SignalHandles::default());
-            for on_spawn in self.on_spawns.lock().unwrap().drain(..) {
-                on_spawn(world, id);
-            }
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the entity does not exist in the world.
+    pub fn spawn_on_entity(self, world: &mut World, entity: Entity) -> Result<(), EntityMutableFetchError> {
+        let mut entity_mut = world.get_entity_mut(entity)?;
+        let id = entity_mut.id();
+        entity_mut.insert((SignalHandles::default(), ChildBlockPopulations::default()));
+        for on_spawn in self.on_spawns {
+            on_spawn(world, id);
         }
+        Ok(())
     }
 
     /// Spawn this builder into the [`World`].
     pub fn spawn(self, world: &mut World) -> Entity {
         let entity = world.spawn_empty().id();
-        self.spawn_on_entity(world, entity);
+        // SAFETY: We just created this entity, so it must exist
+        self.spawn_on_entity(world, entity).unwrap();
         entity
     }
 }
 
 /// A type-erased signal that can be managed as a free-floating "task".
 ///
-/// This trait enables [`JonmoBuilder::hold_tasks`] to accept signals that haven't
+/// This trait enables [`Builder::hold_tasks`] to accept signals that haven't
 /// been registered yet, deferring their registration until the entity is spawned.
 ///
 /// Use the [`.task()`](SignalTaskExt::task) method to convert a [`Signal`],
@@ -810,7 +529,7 @@ impl<S: Signal + SSs> SignalTask for SignalTaskSignal<S> {
 /// Extension trait for converting a [`Signal`] into a [`SignalTask`].
 pub trait SignalTaskExt: Signal + Sized + SSs {
     /// Convert this signal into a type-erased [`SignalTask`] for use with
-    /// [`JonmoBuilder::hold_tasks`].
+    /// [`Builder::hold_tasks`].
     fn task(self) -> Box<dyn SignalTask> {
         Box::new(SignalTaskSignal(self))
     }
@@ -829,7 +548,7 @@ impl<S: SignalVec + SSs> SignalTask for SignalTaskSignalVec<S> {
 /// Extension trait for converting a [`SignalVec`] into a [`SignalTask`].
 pub trait SignalVecTaskExt: SignalVec + Sized + SSs {
     /// Convert this signal vec into a type-erased [`SignalTask`] for use with
-    /// [`JonmoBuilder::hold_tasks`].
+    /// [`Builder::hold_tasks`].
     fn task(self) -> Box<dyn SignalTask> {
         Box::new(SignalTaskSignalVec(self))
     }
@@ -848,7 +567,7 @@ impl<S: SignalMap + SSs> SignalTask for SignalTaskSignalMap<S> {
 /// Extension trait for converting a [`SignalMap`] into a [`SignalTask`].
 pub trait SignalMapTaskExt: SignalMap + Sized + SSs {
     /// Convert this signal map into a type-erased [`SignalTask`] for use with
-    /// [`JonmoBuilder::hold_tasks`].
+    /// [`Builder::hold_tasks`].
     fn task(self) -> Box<dyn SignalTask> {
         Box::new(SignalTaskSignalMap(self))
     }
@@ -878,12 +597,10 @@ fn add_handles<I>(world: &mut World, entity: Entity, handles: I)
 where
     I: IntoIterator<Item = SignalHandle>,
 {
-    if let Ok(mut entity) = world.get_entity_mut(entity)
-        && let Some(mut existing_handles) = entity.get_mut::<SignalHandles>()
-    {
-        for handle in handles {
-            existing_handles.add(handle);
-        }
+    let mut entity = world.entity_mut(entity);
+    let mut existing_handles = entity.get_mut::<SignalHandles>().unwrap();
+    for handle in handles {
+        existing_handles.add(handle);
     }
 }
 
@@ -895,13 +612,16 @@ fn offset(i: usize, child_block_populations: &[usize]) -> usize {
 mod tests {
     use super::*;
     use crate::{
-        JonmoPlugin,
+        self as jonmo, JonmoPlugin,
         graph::STALE_SIGNALS,
-        signal::{SignalBuilder, SignalExt},
-        signal_vec::MutableVecBuilder,
+        signal::{self, SignalExt},
+        signal_vec::MutableVec,
     };
     use bevy::prelude::*;
-    use bevy_platform::collections::HashSet;
+    use bevy_platform::{
+        collections::HashSet,
+        sync::{Arc, Mutex},
+    };
 
     /// Helper to create a minimal Bevy App with the JonmoPlugin for testing.
     fn create_test_app() -> App {
@@ -945,12 +665,12 @@ mod tests {
 
         // The signal reads the resource, extracts the Option, and deduplicates.
         // It will only fire when the i32 value inside SignalSource actually changes.
-        let source_signal = SignalBuilder::from_resource::<SignalSource>()
+        let source_signal = signal::from_resource::<SignalSource>()
             .map_in(|source: SignalSource| source.0)
             .dedupe();
 
         // --- 2. Test Basic Execution & Correct Parameters ---
-        let builder1 = JonmoBuilder::new()
+        let builder1 = jonmo::Builder::new()
             .insert(Name::new("Entity 1"))
             .on_signal(source_signal.clone(), capturing_system);
 
@@ -976,7 +696,7 @@ mod tests {
         app.world_mut().resource_mut::<TestOutput>().0.lock().unwrap().clear();
 
         // --- 3. Test Multi-Entity Support ---
-        let builder2 = JonmoBuilder::new()
+        let builder2 = jonmo::Builder::new()
             .insert(Name::new("Entity 2"))
             .on_signal(source_signal.clone(), capturing_system);
 
@@ -1058,7 +778,7 @@ mod tests {
         app.init_resource::<SignalSource>();
 
         // The signal reads the resource and deduplicates it, so it only fires on change.
-        let source_signal = SignalBuilder::from_resource::<SignalSource>()
+        let source_signal = signal::from_resource::<SignalSource>()
             .map_in(|source: SignalSource| source.0)
             .dedupe();
 
@@ -1069,7 +789,7 @@ mod tests {
         };
 
         // --- 2. Test Basic Functionality ---
-        let builder1 = JonmoBuilder::new()
+        let builder1 = jonmo::Builder::new()
             .insert(TestComponent(10))
             .on_signal_with_component(source_signal.clone(), mutator_closure);
 
@@ -1084,7 +804,7 @@ mod tests {
         assert_eq!(component1.0, 15, "Component should be 10 + 5 = 15.");
 
         // --- 3. Test Graceful Failure (Component Missing) ---
-        let builder_no_comp = JonmoBuilder::new()
+        let builder_no_comp = jonmo::Builder::new()
             // IMPORTANT: We do *not* insert TestComponent here.
             .on_signal_with_component(source_signal.clone(), mutator_closure);
 
@@ -1104,7 +824,7 @@ mod tests {
         assert_eq!(component1.0, 25, "Existing entity should be updated (15 + 10).");
 
         // --- 4. Test Multi-Entity Independence ---
-        let builder2 = JonmoBuilder::new()
+        let builder2 = jonmo::Builder::new()
             .insert(TestComponent(100))
             .on_signal_with_component(source_signal.clone(), mutator_closure);
 
@@ -1142,1562 +862,133 @@ mod tests {
     }
 
     #[test]
-    fn test_signal_from_entity() {
+    fn test_component_signal() {
         // --- 1. Setup ---
         let mut app = create_test_app();
 
-        // A resource to capture the final output of the created signal chains.
-        #[derive(Resource, Default, Clone)]
-        struct TestOutput(Arc<Mutex<Vec<String>>>);
+        // The component that will be reactively added, updated, and removed.
+        #[derive(Component, Clone, Debug, PartialEq)]
+        struct TargetComponent(String);
 
-        app.init_resource::<TestOutput>();
+        // A resource to act as the signal's source.
+        // The Option<String> will be mapped to Option<TargetComponent>.
+        #[derive(Resource, Default, Clone, PartialEq)]
+        struct SignalSource(Option<String>);
 
-        // The component that the signal chain will read from.
-        #[derive(Component, Clone)]
-        struct TestComponent(String);
+        app.init_resource::<SignalSource>();
 
-        // A system to capture the final output of the signal chain.
-        fn capturing_system(In(value): In<String>, output: Res<TestOutput>) {
-            output.0.lock().unwrap().push(value);
-        }
+        // The signal reads the resource and maps its value to the target component.
+        // `.dedupe()` is important to ensure we only process actual changes.
+        let source_signal = signal::from_resource::<SignalSource>()
+            .dedupe()
+            .map_in(|source: SignalSource| {
+                source.0.map(TargetComponent) // Option<String> -> Option<TargetComponent>
+            });
 
-        // The factory closure that will be passed to `signal_from_entity`.
-        // This represents the user's logic.
-        let signal_chain_factory = |entity_signal: crate::signal::Source<Entity>| {
-            // The user takes the entity signal...
-            entity_signal
-                // ...maps it to get a component from that entity...
-                .map(|In(entity): In<Entity>, query: Query<&TestComponent>| query.get(entity).ok().cloned()) // ...extracts the inner string...
-                .map_in(|component: TestComponent| component.0)
-                // ...and finally pipes it to our capturing system.
-                .map(capturing_system)
-        };
+        // --- 2. Test Initial Insertion ---
+        let builder = jonmo::Builder::new().component_signal(source_signal.clone());
+        let entity1 = builder.spawn(app.world_mut());
 
-        // --- 2. Test Basic Functionality ---
-        let builder1 = JonmoBuilder::new()
-            .insert(TestComponent("Data A".to_string()))
-            .signal_from_entity(signal_chain_factory);
+        // The signal hasn't run yet, so the component should not be present.
+        assert!(app.world().get::<TargetComponent>(entity1).is_none());
 
-        let entity1 = builder1.spawn(app.world_mut());
+        // Set the source to an initial value.
+        app.world_mut().resource_mut::<SignalSource>().0 = Some("Initial".to_string());
         app.update();
 
-        // Verify the output.
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1, "Signal chain should have run once.");
-        assert_eq!(output_guard[0], "Data A", "Signal chain produced incorrect output.");
-        drop(output_guard);
-        app.world_mut().resource_mut::<TestOutput>().0.lock().unwrap().clear();
+        // Now the component should exist with the initial value.
+        assert_eq!(
+            app.world().get::<TargetComponent>(entity1),
+            Some(&TargetComponent("Initial".to_string())),
+            "Component should be inserted on first Some signal."
+        );
 
-        // --- 3. Test Multi-Entity Independence ---
-        let builder2 = JonmoBuilder::new()
-            .insert(TestComponent("Data B".to_string()))
-            .signal_from_entity(signal_chain_factory);
+        // --- 3. Test Reactive Update ---
+        // Change the source value.
+        app.world_mut().resource_mut::<SignalSource>().0 = Some("Updated".to_string());
+        app.update();
 
-        let entity2 = builder2.spawn(app.world_mut());
+        // The component on the entity should be updated.
+        assert_eq!(
+            app.world().get::<TargetComponent>(entity1),
+            Some(&TargetComponent("Updated".to_string())),
+            "Component should be updated on subsequent Some signal."
+        );
+
+        // --- 4. Test Reactive Removal ---
+        // Set the source to None.
+        app.world_mut().resource_mut::<SignalSource>().0 = None;
         app.update();
 
-        // Verify that both signal chains ran independently. Order is not guaranteed.
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 2, "Both signal chains should have run.");
-        let received_set: HashSet<String> = output_guard.iter().cloned().collect();
-        let expected_set: HashSet<String> = ["Data A".to_string(), "Data B".to_string()].into();
+        // The component should now be removed from the entity.
+        assert!(
+            app.world().get::<TargetComponent>(entity1).is_none(),
+            "Component should be removed on None signal."
+        );
+
+        // --- 5. Test Reactive Re-insertion ---
+        // Set the source back to a Some value.
+        app.world_mut().resource_mut::<SignalSource>().0 = Some("Reinserted".to_string());
+        app.update();
+
+        // The component should be added back to the entity.
         assert_eq!(
-            received_set, expected_set,
-            "Multi-entity test produced incorrect or incomplete output."
+            app.world().get::<TargetComponent>(entity1),
+            Some(&TargetComponent("Reinserted".to_string())),
+            "Component should be re-inserted after being removed."
         );
-        drop(output_guard);
-        app.world_mut().resource_mut::<TestOutput>().0.lock().unwrap().clear();
 
-        // --- 4. Test Automatic Cleanup ---
-        // Despawn the first entity.
-        app.world_mut().entity_mut(entity1).despawn();
-        app.update(); // This update processes the despawn AND runs the graph for entity2.
+        // --- 6. Test Multi-Entity Independence ---
+        let builder2 = jonmo::Builder::new().component_signal(source_signal.clone());
+        let entity2 = builder2.spawn(app.world_mut());
 
-        // Clear the output from the update call above to isolate the next frame's result.
-        app.world_mut().resource_mut::<TestOutput>().0.lock().unwrap().clear();
+        // The new entity should not have the component yet (signal will fire next update).
+        assert!(app.world().get::<TargetComponent>(entity2).is_none());
 
-        // Update again to run the signal graph, now that entity1's signal is gone.
+        // Update the source. This will trigger updates for both entities.
+        app.world_mut().resource_mut::<SignalSource>().0 = Some("Multi".to_string());
         app.update();
 
-        // Verify that only the signal for the second entity ran in this last frame.
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
+        // Both entities should now have the new component value.
         assert_eq!(
-            output_guard.len(),
-            1,
-            "Only the signal for the remaining entity should have run."
+            app.world().get::<TargetComponent>(entity1),
+            Some(&TargetComponent("Multi".to_string())),
+            "Entity 1 should be updated in multi-entity test."
         );
         assert_eq!(
-            output_guard[0], "Data B",
-            "The remaining signal produced incorrect output."
+            app.world().get::<TargetComponent>(entity2),
+            Some(&TargetComponent("Multi".to_string())),
+            "Entity 2 should be updated in multi-entity test."
         );
-        drop(output_guard);
 
-        // Despawn the second entity.
-        app.world_mut().entity_mut(entity2).despawn();
-        app.update();
-        app.world_mut().resource_mut::<TestOutput>().0.lock().unwrap().clear();
+        // --- 7. Test Automatic Cleanup ---
+        // Despawn the first entity.
+        app.world_mut().entity_mut(entity1).despawn();
+        app.update(); // Process the despawn command.
 
-        // Update again. Nothing should run now.
+        // Change the source value one last time.
+        app.world_mut().resource_mut::<SignalSource>().0 = Some("Post-Despawn".to_string());
         app.update();
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
+
+        // Verify that only the second entity was updated.
+        assert_eq!(
+            app.world().get::<TargetComponent>(entity2),
+            Some(&TargetComponent("Post-Despawn".to_string())),
+            "Only the remaining entity should have been updated."
+        );
+
+        // Verify the first entity is gone.
         assert!(
-            output_guard.is_empty(),
-            "No signals should run after all entities are despawned."
+            app.world().get_entity(entity1).is_err(),
+            "Despawned entity should not exist."
         );
     }
 
     #[test]
-    fn test_signal_from_component() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        #[derive(Resource, Default, Clone)]
-        struct TestOutput(Arc<Mutex<Vec<String>>>);
-        app.init_resource::<TestOutput>();
-
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TestComponent(String);
-
-        fn capturing_system(In(value): In<String>, output: Res<TestOutput>) {
-            output.0.lock().unwrap().push(value);
-        }
-
-        let signal_chain_factory =
-            |component_signal: crate::signal::Map<crate::signal::Source<Entity>, TestComponent>| {
-                component_signal
-                    .map_in(|component: TestComponent| component.0)
-                    .dedupe()
-                    .map(capturing_system)
-            };
-
-        // --- 2. Test Basic Functionality & Reactivity ---
-        let builder1 = JonmoBuilder::new()
-            .insert(TestComponent("Initial A".to_string()))
-            .signal_from_component(signal_chain_factory);
-
-        let entity1 = builder1.spawn(app.world_mut());
-
-        app.update();
-        let output = app.world_mut().resource_mut::<TestOutput>();
-        let mut output_guard = output.0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1);
-        assert_eq!(output_guard[0], "Initial A");
-        output_guard.clear();
-        drop(output_guard);
-
-        app.update();
-        assert!(app.world().resource::<TestOutput>().0.lock().unwrap().is_empty());
-
-        app.world_mut().get_mut::<TestComponent>(entity1).unwrap().0 = "Updated A".to_string();
-        app.update();
-        let output = app.world_mut().resource_mut::<TestOutput>();
-        let mut output_guard = output.0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1);
-        assert_eq!(output_guard[0], "Updated A");
-        output_guard.clear();
-        drop(output_guard);
-
-        // --- 3. Test Graceful Failure (Component Missing) ---
-        let builder_no_comp = JonmoBuilder::new().signal_from_component(signal_chain_factory);
-        let _entity_no_comp = builder_no_comp.spawn(app.world_mut());
-        app.update();
-        assert!(app.world().resource::<TestOutput>().0.lock().unwrap().is_empty());
-
-        // --- 4. Test Multi-Entity Independence ---
-        let builder2 = JonmoBuilder::new()
-            .insert(TestComponent("Initial B".to_string()))
-            .signal_from_component(signal_chain_factory);
-
-        let entity2 = builder2.spawn(app.world_mut());
-
-        // CORRECTED: To ensure both signals fire, we must change entity1's data again
-        // so that its `dedupe` operator will allow the signal to pass.
-        app.world_mut().get_mut::<TestComponent>(entity1).unwrap().0 = "Final A".to_string();
-        app.update();
-
-        let output = app.world_mut().resource_mut::<TestOutput>();
-        let mut output_guard = output.0.lock().unwrap();
-        // assert_eq!(output_guard.len(), 1);
-        assert_eq!(output_guard.len(), 2, "Both signals should have run.");
-        let received_set: HashSet<String> = output_guard.iter().cloned().collect();
-        let expected_set: HashSet<String> = ["Final A".to_string(), "Initial B".to_string()].into();
-        assert_eq!(received_set, expected_set);
-        output_guard.clear();
-        drop(output_guard);
-
-        // --- 5. Test Automatic Cleanup ---
-        app.world_mut().entity_mut(entity1).despawn();
-        app.update();
-
-        app.world_mut().resource_mut::<TestOutput>().0.lock().unwrap().clear();
-
-        app.world_mut().get_mut::<TestComponent>(entity2).unwrap().0 = "Updated B".to_string();
-        app.update();
-
-        let output = app.world_mut().resource_mut::<TestOutput>();
-        let mut output_guard = output.0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1);
-        assert_eq!(
-            output_guard.len(),
-            1,
-            "Only the signal for the remaining entity should run."
-        );
-        assert_eq!(output_guard[0], "Updated B");
-        output_guard.clear();
-    }
-
-    #[test]
-    fn test_signal_from_component_option() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // Resource to capture the final string output of the signal chains.
-        #[derive(Resource, Default, Clone)]
-        struct TestOutput(Arc<Mutex<Vec<String>>>);
-        app.init_resource::<TestOutput>();
-
-        // The component that the signal chain will read from.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TestComponent(String);
-
-        // System to capture the final output.
-        fn capturing_system(In(value): In<String>, output: Res<TestOutput>) {
-            output.0.lock().unwrap().push(value);
-        }
-
-        // The factory closure that will be passed to `signal_from_component_option`.
-        // It defines the signal logic after the component is read.
-        let signal_chain_factory =
-            |component_opt_signal: crate::signal::Map<crate::signal::Source<Entity>, Option<TestComponent>>| {
-                component_opt_signal
-                    .dedupe() // Use dedupe to test reactivity correctly.
-                    .map_in(|opt_component: Option<TestComponent>| {
-                        // This logic is key: we transform both Some and None cases into a string.
-                        match opt_component {
-                            Some(component) => format!("Some({})", component.0),
-                            None => "None".to_string(),
-                        }
-                    })
-                    .map(capturing_system)
-            };
-
-        // --- 2. Test Case: Component Present ---
-        let builder_with_comp = JonmoBuilder::new()
-            .insert(TestComponent("Data A".to_string()))
-            .signal_from_component_option(signal_chain_factory);
-
-        let entity_with_comp = builder_with_comp.spawn(app.world_mut());
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1);
-        assert_eq!(output_guard[0], "Some(Data A)");
-        output_guard.clear();
-        drop(output_guard);
-
-        // --- 3. Test Case: Component Missing ---
-        // This is the main difference from `signal_from_component`. The chain should still run.
-        let builder_without_comp = JonmoBuilder::new().signal_from_component_option(signal_chain_factory);
-
-        let entity_without_comp = builder_without_comp.spawn(app.world_mut());
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(
-            output_guard.len(),
-            1,
-            "Signal for entity without component should have run."
-        );
-        assert_eq!(
-            output_guard[0], "None",
-            "Signal should have received None for the missing component."
-        );
-        output_guard.clear();
-        drop(output_guard);
-
-        // --- 4. Test Case: Reactivity ---
-        // Change the component on the first entity.
-        app.world_mut().get_mut::<TestComponent>(entity_with_comp).unwrap().0 = "Updated A".to_string();
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1, "Signal should re-run on component change.");
-        assert_eq!(output_guard[0], "Some(Updated A)");
-        output_guard.clear();
-        drop(output_guard);
-
-        // Run again without changes. Due to `.dedupe()`, it shouldn't fire.
-        app.update();
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not run when component is unchanged due to dedupe."
-        );
-        drop(output_guard);
-
-        // --- 5. Test Case: Automatic Cleanup ---
-        // Despawn the entity with the component.
-        app.world_mut().entity_mut(entity_with_comp).despawn();
-        app.update(); // Process despawn commands.
-
-        // To verify cleanup, we'll add the component to the *other* entity.
-        // Only its signal should run, proving the first one was cleaned up.
-        app.world_mut()
-            .entity_mut(entity_without_comp)
-            .insert(TestComponent("Data B".to_string()));
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(
-            output_guard.len(),
-            1,
-            "Only the signal for the remaining entity should run."
-        );
-        assert_eq!(output_guard[0], "Some(Data B)");
-        output_guard.clear();
-        drop(output_guard);
-    }
-
-    #[test]
-    fn test_signal_from_ancestor() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        #[derive(Resource, Default, Clone)]
-        struct TestOutput(Arc<Mutex<Vec<String>>>);
-        app.init_resource::<TestOutput>();
-
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TestComponent(String);
-
-        fn capturing_system(In(value): In<String>, output: Res<TestOutput>) {
-            output.0.lock().unwrap().push(value);
-        }
-
-        // A reusable factory for the signal logic. It takes a signal of an ancestor's
-        // entity, gets its TestComponent, and sends the inner string to the output.
-        let signal_chain_factory =
-            |ancestor_entity_signal: crate::signal::Map<crate::signal::Source<Entity>, Entity>| {
-                ancestor_entity_signal
-                    // Map the ancestor entity to its component. This will terminate if the
-                    // ancestor doesn't have the component.
-                    .map(|In(entity): In<Entity>, query: Query<&TestComponent>| query.get(entity).ok().cloned())
-                    .map_in(|component: TestComponent| component.0) // Extract the string
-                    .map(capturing_system)
-            };
-
-        // Create a 3-level entity hierarchy for testing: Grandparent -> Parent -> Child
-        let grandparent = app.world_mut().spawn(TestComponent("Grandparent".to_string())).id();
-        let parent = app.world_mut().spawn(TestComponent("Parent".to_string())).id();
-        app.world_mut().entity_mut(grandparent).add_child(parent);
-
-        // --- 2. Test Case: generations = 0 (Self) ---
-        // The builder should target its own entity.
-        let child_for_self_test = app
-            .world_mut()
-            .spawn(TestComponent("Child".to_string())) // Give the child its own component
-            .id();
-        app.world_mut().entity_mut(parent).add_child(child_for_self_test);
-
-        let builder_self = JonmoBuilder::new().signal_from_ancestor(0, signal_chain_factory);
-        builder_self.spawn_on_entity(app.world_mut(), child_for_self_test);
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1);
-        assert_eq!(output_guard[0], "Child");
-        output_guard.clear();
-        drop(output_guard);
-        app.world_mut().entity_mut(child_for_self_test).despawn();
-        app.update();
-
-        // --- 3. Test Case: generations = 1 (Parent) ---
-        let child_for_parent_test = app.world_mut().spawn_empty().id();
-        app.world_mut().entity_mut(parent).add_child(child_for_parent_test);
-        let builder_parent = JonmoBuilder::new().signal_from_ancestor(1, signal_chain_factory);
-        builder_parent.spawn_on_entity(app.world_mut(), child_for_parent_test);
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1);
-        assert_eq!(output_guard[0], "Parent");
-        output_guard.clear();
-        drop(output_guard);
-        app.world_mut().entity_mut(child_for_parent_test).despawn();
-        app.update();
-
-        // --- 4. Test Case: generations = 2 (Grandparent) ---
-        let child_for_gp_test = app.world_mut().spawn_empty().id();
-        app.world_mut().entity_mut(parent).add_child(child_for_gp_test);
-        let builder_gp = JonmoBuilder::new().signal_from_ancestor(2, signal_chain_factory);
-        builder_gp.spawn_on_entity(app.world_mut(), child_for_gp_test);
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1);
-        assert_eq!(output_guard[0], "Grandparent");
-        output_guard.clear();
-        drop(output_guard);
-        app.world_mut().entity_mut(child_for_gp_test).despawn();
-        app.update();
-
-        // --- 5. Test Case: Invalid Ancestor (Too many generations) ---
-        let child_for_invalid_test = app.world_mut().spawn_empty().id();
-        app.world_mut().entity_mut(parent).add_child(child_for_invalid_test);
-        let builder_invalid = JonmoBuilder::new().signal_from_ancestor(3, signal_chain_factory);
-        builder_invalid.spawn_on_entity(app.world_mut(), child_for_invalid_test);
-        app.update();
-
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not run for an invalid ancestor."
-        );
-        drop(output_guard);
-        app.world_mut().entity_mut(child_for_invalid_test).despawn();
-        app.update();
-
-        // --- 6. Test Case: Reactivity ---
-        let child_for_reactivity_test = app.world_mut().spawn_empty().id();
-        app.world_mut().entity_mut(parent).add_child(child_for_reactivity_test);
-        let builder_reactivity = JonmoBuilder::new().signal_from_ancestor(1, signal_chain_factory);
-        builder_reactivity.spawn_on_entity(app.world_mut(), child_for_reactivity_test);
-        app.update(); // Initial run
-        app.world_mut().resource_mut::<TestOutput>().0.lock().unwrap().clear(); // Clear initial output
-
-        // Modify the parent's component
-        app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent Updated".to_string();
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1, "Signal did not re-run on ancestor change.");
-        assert_eq!(output_guard[0], "Parent Updated");
-        output_guard.clear();
-        drop(output_guard);
-
-        // --- 7. Test Case: Automatic Cleanup ---
-        // Despawn the child entity that holds the signal
-        app.world_mut().entity_mut(child_for_reactivity_test).despawn();
-        app.update(); // Process despawn commands
-
-        // Modify the parent's component again
-        app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent Updated Again".to_string();
-        app.update();
-
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not run after its entity is despawned."
-        );
-    }
-
-    #[test]
-    fn test_signal_from_parent() {
-        {
-            // --- 1. Setup ---
-            let mut app = create_test_app();
-
-            // A resource to capture the final output of the signal chains.
-            #[derive(Resource, Default, Clone)]
-            struct TestOutput(Arc<Mutex<Vec<String>>>);
-            app.init_resource::<TestOutput>();
-
-            // The component that the signal chain will read from the parent.
-            #[derive(Component, Clone, Debug, PartialEq)]
-            struct TestComponent(String);
-
-            // A system to capture the final output of the signal chain.
-            fn capturing_system(In(value): In<String>, output: Res<TestOutput>) {
-                output.0.lock().unwrap().push(value);
-            }
-
-            // The factory closure that will be passed to `signal_from_parent`.
-            // This represents the user's logic. It gets a signal for the parent entity,
-            // reads its TestComponent, extracts the string, and sends it to be captured.
-            let signal_chain_factory =
-                |parent_entity_signal: crate::signal::Map<crate::signal::Source<Entity>, Entity>| {
-                    parent_entity_signal
-                        // Map the parent entity to its component. This will terminate if the
-                        // parent doesn't have the component.
-                        .map(|In(entity): In<Entity>, query: Query<&TestComponent>| query.get(entity).ok().cloned())
-                        .map_in(|component: TestComponent| component.0) // Extract the string
-                        .dedupe() // Add dedupe for robust reactivity testing
-                        .map(capturing_system)
-                };
-
-            // --- 2. Test Case: Basic Functionality & Reactivity ---
-            let parent = app.world_mut().spawn(TestComponent("Parent A".to_string())).id();
-            let child = app.world_mut().spawn_empty().id();
-            app.world_mut().entity_mut(parent).add_child(child);
-
-            let builder_with_parent = JonmoBuilder::new().signal_from_parent(signal_chain_factory);
-            builder_with_parent.spawn_on_entity(app.world_mut(), child);
-
-            // Initial run
-            app.update();
-            let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-            assert_eq!(output_guard.len(), 1, "Signal should run on initialization.");
-            assert_eq!(output_guard[0], "Parent A");
-            output_guard.clear();
-            drop(output_guard);
-
-            // Reactivity test
-            app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent B".to_string();
-            app.update();
-            let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-            assert_eq!(
-                output_guard.len(),
-                1,
-                "Signal should re-run on parent component change."
-            );
-            assert_eq!(output_guard[0], "Parent B");
-            output_guard.clear();
-            drop(output_guard);
-
-            // --- 3. Test Case: No Parent ---
-            // A top-level entity with this signal should not run the chain.
-            let _top_level_entity = JonmoBuilder::new()
-                .signal_from_parent(signal_chain_factory)
-                .spawn(app.world_mut());
-            app.update();
-            let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-            assert!(
-                output_guard.is_empty(),
-                "Signal should not run for an entity with no parent."
-            );
-            drop(output_guard);
-
-            // --- 4. Test Case: Parent Without Component ---
-            // The signal chain should terminate gracefully if the parent is missing the component.
-            let parent_no_comp = app.world_mut().spawn_empty().id();
-            let child_of_plain_parent = app.world_mut().spawn_empty().id();
-            app.world_mut()
-                .entity_mut(parent_no_comp)
-                .add_child(child_of_plain_parent);
-
-            let builder_plain_parent = JonmoBuilder::new().signal_from_parent(signal_chain_factory);
-            builder_plain_parent.spawn_on_entity(app.world_mut(), child_of_plain_parent);
-            app.update();
-            let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-            assert!(
-                output_guard.is_empty(),
-                "Signal should not run if parent is missing the target component."
-            );
-            drop(output_guard);
-
-            // --- 5. Test Case: Automatic Cleanup ---
-            // Despawn the child entity that holds the signal.
-            app.world_mut().entity_mut(child).despawn();
-            app.update(); // Process despawn commands.
-
-            // Modify the parent's component again. The signal should no longer be active.
-            app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent C".to_string();
-            app.update();
-
-            let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-            assert!(
-                output_guard.is_empty(),
-                "Signal should not run after its entity is despawned."
-            );
-        }
-
-        STALE_SIGNALS.lock().unwrap().clear();
-    }
-
-    #[test]
-    fn test_component_signal() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // The component that will be reactively added, updated, and removed.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TargetComponent(String);
-
-        // A resource to act as the signal's source.
-        // The Option<String> will be mapped to Option<TargetComponent>.
-        #[derive(Resource, Default, Clone, PartialEq)]
-        struct SignalSource(Option<String>);
-
-        app.init_resource::<SignalSource>();
-
-        // The signal reads the resource and maps its value to the target component.
-        // `.dedupe()` is important to ensure we only process actual changes.
-        let source_signal = SignalBuilder::from_resource::<SignalSource>()
-            .dedupe()
-            .map_in(|source: SignalSource| {
-                source.0.map(TargetComponent) // Option<String> -> Option<TargetComponent>
-            });
-
-        // --- 2. Test Initial Insertion ---
-        let builder = JonmoBuilder::new().component_signal(source_signal.clone());
-        let entity1 = builder.spawn(app.world_mut());
-
-        // The signal hasn't run yet, so the component should not be present.
-        assert!(app.world().get::<TargetComponent>(entity1).is_none());
-
-        // Set the source to an initial value.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Initial".to_string());
-        app.update();
-
-        // Now the component should exist with the initial value.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Initial".to_string())),
-            "Component should be inserted on first Some signal."
-        );
-
-        // --- 3. Test Reactive Update ---
-        // Change the source value.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Updated".to_string());
-        app.update();
-
-        // The component on the entity should be updated.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Updated".to_string())),
-            "Component should be updated on subsequent Some signal."
-        );
-
-        // --- 4. Test Reactive Removal ---
-        // Set the source to None.
-        app.world_mut().resource_mut::<SignalSource>().0 = None;
-        app.update();
-
-        // The component should now be removed from the entity.
-        assert!(
-            app.world().get::<TargetComponent>(entity1).is_none(),
-            "Component should be removed on None signal."
-        );
-
-        // --- 5. Test Reactive Re-insertion ---
-        // Set the source back to a Some value.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Reinserted".to_string());
-        app.update();
-
-        // The component should be added back to the entity.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Reinserted".to_string())),
-            "Component should be re-inserted after being removed."
-        );
-
-        // --- 6. Test Multi-Entity Independence ---
-        let builder2 = JonmoBuilder::new().component_signal(source_signal.clone());
-        let entity2 = builder2.spawn(app.world_mut());
-
-        // The new entity should not have the component yet (signal will fire next update).
-        assert!(app.world().get::<TargetComponent>(entity2).is_none());
-
-        // Update the source. This will trigger updates for both entities.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Multi".to_string());
-        app.update();
-
-        // Both entities should now have the new component value.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Multi".to_string())),
-            "Entity 1 should be updated in multi-entity test."
-        );
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity2),
-            Some(&TargetComponent("Multi".to_string())),
-            "Entity 2 should be updated in multi-entity test."
-        );
-
-        // --- 7. Test Automatic Cleanup ---
-        // Despawn the first entity.
-        app.world_mut().entity_mut(entity1).despawn();
-        app.update(); // Process the despawn command.
-
-        // Change the source value one last time.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Post-Despawn".to_string());
-        app.update();
-
-        // Verify that only the second entity was updated.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity2),
-            Some(&TargetComponent("Post-Despawn".to_string())),
-            "Only the remaining entity should have been updated."
-        );
-
-        // Verify the first entity is gone.
-        assert!(
-            app.world().get_entity(entity1).is_err(),
-            "Despawned entity should not exist."
-        );
-    }
-
-    #[test]
-    fn test_signal_from_component_changed() {
-        // --- 1. Setup ---
-        // Create the standard test app with the JonmoPlugin.
-        let mut app = create_test_app();
-
-        // A resource to capture the final string output of the signal chains.
-        #[derive(Resource, Default, Clone)]
-        struct TestOutput(Arc<Mutex<Vec<String>>>);
-        app.init_resource::<TestOutput>();
-
-        // A system to capture the final output of the signal chain.
-        fn capturing_system(In(value): In<String>, output: Res<TestOutput>) {
-            output.0.lock().unwrap().push(value);
-        }
-
-        // The component that will be tracked for changes.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TrackedComponent(String);
-
-        // The factory closure that will be passed to `signal_from_component_changed`.
-        // This represents the user's logic: it takes the signal of the changed component,
-        // extracts its inner string, and sends it to the capturing system.
-        let signal_chain_factory =
-            |component_signal: crate::signal::Map<crate::signal::Source<Entity>, TrackedComponent>| {
-                component_signal
-                    .map_in(|component: TrackedComponent| component.0)
-                    // Note: `.dedupe()` is not needed here, as the `Changed<C>` filter
-                    // in the implementation already prevents firing on unchanged frames.
-                    .map(capturing_system)
-            };
-
-        // --- 2. Test Initial State & No-Change Frame ---
-        let builder1 = JonmoBuilder::new()
-            .insert(TrackedComponent("Initial".to_string()))
-            .signal_from_component_changed(signal_chain_factory);
-
-        let entity1 = builder1.spawn(app.world_mut());
-
-        // Frame 1: The component is newly added (`Added<C>`), which counts as `Changed<C>`.
-        // The signal should fire.
-        app.update();
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(
-            output_guard.len(),
-            1,
-            "Signal should fire on initial component insertion."
-        );
-        assert_eq!(output_guard[0], "Initial");
-        output_guard.clear();
-        drop(output_guard);
-
-        // Frame 2: No changes were made to the component. The signal should NOT fire.
-        app.update();
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not fire when component is unchanged."
-        );
-        drop(output_guard);
-
-        // --- 3. Test Component Changed ---
-        // Explicitly mutate the component to mark it as `Changed`.
-        app.world_mut().get_mut::<TrackedComponent>(entity1).unwrap().0 = "Updated".to_string();
-
-        // Frame 3: The component is now `Changed`. The signal should fire again.
-        app.update();
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1, "Signal should fire after component is mutated.");
-        assert_eq!(output_guard[0], "Updated");
-        output_guard.clear();
-        drop(output_guard);
-
-        // Frame 4: No changes were made in this frame. The signal should NOT fire.
-        app.update();
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not fire on the frame after a change."
-        );
-        drop(output_guard);
-
-        // --- 4. Test Graceful Failure (Component Missing) ---
-        // Spawn an entity with the signal but without the component.
-        // The signal chain should terminate gracefully and not panic or produce output.
-        let builder_no_comp = JonmoBuilder::new().signal_from_component_changed(signal_chain_factory);
-        let _entity_no_comp = builder_no_comp.spawn(app.world_mut());
-
-        app.update();
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not fire for an entity missing the component."
-        );
-        drop(output_guard);
-
-        // --- 5. Test Multi-Entity Independence ---
-        let builder2 = JonmoBuilder::new()
-            .insert(TrackedComponent("Entity 2 Initial".to_string()))
-            .signal_from_component_changed(signal_chain_factory);
-        let entity2 = builder2.spawn(app.world_mut());
-
-        // Frame 5: Only entity2's component is new. Only its signal should fire.
-        app.update();
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1, "Only the new entity's signal should fire.");
-        assert_eq!(output_guard[0], "Entity 2 Initial");
-        output_guard.clear();
-        drop(output_guard);
-
-        // Frame 6: Mutate both entities' components in the same frame.
-        app.world_mut().get_mut::<TrackedComponent>(entity1).unwrap().0 = "Entity 1 Final".to_string();
-        app.world_mut().get_mut::<TrackedComponent>(entity2).unwrap().0 = "Entity 2 Final".to_string();
-        app.update();
-
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(
-            output_guard.len(),
-            2,
-            "Both signals should fire when both components change."
-        );
-        // Use a HashSet because the order of execution is not guaranteed.
-        let received_set: HashSet<String> = output_guard.iter().cloned().collect();
-        let expected_set: HashSet<String> = ["Entity 1 Final".to_string(), "Entity 2 Final".to_string()].into();
-        assert_eq!(
-            received_set, expected_set,
-            "Multi-entity change produced incorrect output."
-        );
-        drop(output_guard);
-
-        // --- 6. Test Automatic Cleanup ---
-        // Despawn the first entity.
-        app.world_mut().entity_mut(entity1).despawn();
-        app.update(); // Process the despawn command.
-
-        // Clear output from the last update cycle.
-        app.world_mut().resource_mut::<TestOutput>().0.lock().unwrap().clear();
-
-        // Mutate the remaining entity's component.
-        app.world_mut().get_mut::<TrackedComponent>(entity2).unwrap().0 = "Entity 2 Post-Despawn".to_string();
-        app.update();
-
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(
-            output_guard.len(),
-            1,
-            "Only the remaining entity's signal should fire after despawn."
-        );
-        assert_eq!(output_guard[0], "Entity 2 Post-Despawn");
-        output_guard.clear();
-        drop(output_guard);
-
-        // Verify entity1 is truly gone.
-        assert!(
-            app.world().get_entity(entity1).is_err(),
-            "Despawned entity should not exist."
-        );
-    }
-
-    #[test]
-    fn test_component_signal_from_entity() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // The component that will be reactively added, updated, and removed.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TargetComponent(String);
-
-        // A resource to act as the signal's external trigger. Its Option<String>
-        // will be mapped to Option<TargetComponent>.
-        #[derive(Resource, Default, Clone, PartialEq)]
-        struct SignalSource(Option<String>);
-        app.init_resource::<SignalSource>();
-
-        // The factory closure that defines the signal logic.
-        // It demonstrates that the closure correctly receives the entity signal
-        // by using the entity's `Name` component in its logic.
-        let signal_factory = |entity_signal: crate::signal::Source<Entity>| {
-            // Combine the entity signal with the global source signal.
-            entity_signal
-                .with(SignalBuilder::from_resource::<SignalSource>().dedupe())
-                // The `.map` combinator gives us access to other `SystemParam`s, like `Query`.
-                .map(
-                    |In((entity, source)): In<(Entity, SignalSource)>, names: Query<&Name>| {
-                        // Get the name from the specific entity this signal is for.
-                        let name = names.get(entity).map_or("Unnamed", |n| n.as_str());
-                        // Map the source data into the target component, including the entity's name.
-                        source.0.map(|s| TargetComponent(format!("{s} for {name}")))
-                    },
-                )
-        };
-
-        // --- 2. Test Initial Insertion ---
-        let builder1 = JonmoBuilder::new()
-            .insert(Name::new("Entity1"))
-            .component_signal_from_entity(signal_factory);
-
-        // Set the source *before* spawning.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Initial".to_string());
-        let entity1 = builder1.spawn(app.world_mut());
-
-        // The signal chain runs on the first update after spawning.
-        app.update();
-
-        // Verify the component was inserted correctly.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Initial for Entity1".to_string())),
-            "Component should be inserted on first run."
-        );
-
-        // --- 3. Test Reactive Update ---
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Updated".to_string());
-        app.update();
-
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Updated for Entity1".to_string())),
-            "Component should be updated on signal change."
-        );
-
-        // --- 4. Test Reactive Removal ---
-        app.world_mut().resource_mut::<SignalSource>().0 = None;
-        app.update();
-
-        assert!(
-            app.world().get::<TargetComponent>(entity1).is_none(),
-            "Component should be removed when signal emits None."
-        );
-
-        // --- 5. Test Reactive Re-insertion ---
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Reinserted".to_string());
-        app.update();
-
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Reinserted for Entity1".to_string())),
-            "Component should be re-inserted after being removed."
-        );
-
-        // --- 6. Test Multi-Entity Independence ---
-        let builder2 = JonmoBuilder::new()
-            .insert(Name::new("Entity2"))
-            .component_signal_from_entity(signal_factory);
-
-        let entity2 = builder2.spawn(app.world_mut());
-
-        // Trigger an update for both.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Multi".to_string());
-        app.update();
-
-        // Verify both entities were updated correctly and independently.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Multi for Entity1".to_string())),
-            "Entity 1 should be updated in multi-entity test."
-        );
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity2),
-            Some(&TargetComponent("Multi for Entity2".to_string())),
-            "Entity 2 should be updated in multi-entity test."
-        );
-
-        // --- 7. Test Automatic Cleanup ---
-        app.world_mut().entity_mut(entity1).despawn();
-        app.update(); // Process despawn command.
-
-        // Trigger another update.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some("Post-Despawn".to_string());
-        app.update();
-
-        // Verify the despawned entity is gone and its signal didn't run.
-        assert!(
-            app.world().get_entity(entity1).is_err(),
-            "Despawned entity should not exist."
-        );
-
-        // Verify that only the second entity was updated.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity2),
-            Some(&TargetComponent("Post-Despawn for Entity2".to_string())),
-            "Only the remaining entity should have been updated."
-        );
-    }
-
-    // Add the components required for the new test
-    #[derive(Component, Clone, Debug, PartialEq)]
-    struct SourceComponent(String);
-
-    #[derive(Component, Clone, Debug, PartialEq)]
-    struct TargetComponent(String);
-
-    #[test]
-    fn test_component_signal_from_ancestor() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // The factory closure defines the reusable signal logic.
-        // It takes a signal of an ancestor's entity, gets its `SourceComponent`,
-        // and maps it to an `Option<TargetComponent>`. The final `Option` is crucial,
-        // as `None` will trigger the removal of the `TargetComponent`.
-        let signal_factory = |ancestor_signal: crate::signal::Map<crate::signal::Source<Entity>, Entity>| {
-            ancestor_signal
-                // Map the ancestor entity to its `SourceComponent`.
-                // This produces `None` if the component doesn't exist, which is desired.
-                .map(|In(entity): In<Entity>, query: Query<&SourceComponent>| query.get(entity).ok().cloned())
-                // Map the `Option<SourceComponent>` to `Option<TargetComponent>`.
-                .map_in(|opt_source: Option<SourceComponent>| opt_source.map(|source| TargetComponent(source.0)))
-                // Dedupe to avoid    unnecessary updates if the source value doesn't change.
-                .dedupe()
-        };
-
-        // Create a 3-level entity hierarchy for testing different `generations`.
-        let grandparent = app.world_mut().spawn(SourceComponent("Grandparent".to_string())).id();
-        let parent = app.world_mut().spawn(SourceComponent("Parent".to_string())).id();
-        app.world_mut().entity_mut(grandparent).add_child(parent);
-
-        // --- 2. Test Parent (`generations = 1`) ---
-        let child_from_parent = JonmoBuilder::new()
-            .component_signal_from_ancestor(1, signal_factory)
-            .spawn(app.world_mut());
-        app.world_mut().entity_mut(parent).add_child(child_from_parent);
-
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(child_from_parent),
-            Some(&TargetComponent("Parent".to_string())),
-            "Child should get component from parent (gen 1)."
-        );
-
-        // --- 3. Test Grandparent (`generations = 2`) ---
-        let child_from_gp = JonmoBuilder::new()
-            .component_signal_from_ancestor(2, signal_factory)
-            .spawn(app.world_mut());
-        app.world_mut().entity_mut(parent).add_child(child_from_gp);
-
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(child_from_gp),
-            Some(&TargetComponent("Grandparent".to_string())),
-            "Child should get component from grandparent (gen 2)."
-        );
-
-        // --- 4. Test Self (`generations = 0`) ---
-        let child_from_self = JonmoBuilder::new()
-            .insert(SourceComponent("Self".to_string()))
-            .component_signal_from_ancestor(0, signal_factory)
-            .spawn(app.world_mut());
-        app.world_mut().entity_mut(parent).add_child(child_from_self);
-
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(child_from_self),
-            Some(&TargetComponent("Self".to_string())),
-            "Child should get component from itself (gen 0)."
-        );
-
-        // --- 5. Test Reactivity (Update, Remove, Re-add) ---
-        // Use the `child_from_parent` for this test.
-
-        // Update the parent's source component.
-        app.world_mut().get_mut::<SourceComponent>(parent).unwrap().0 = "Parent Updated".to_string();
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(child_from_parent),
-            Some(&TargetComponent("Parent Updated".to_string())),
-            "Child's component should update when parent's component changes."
-        );
-
-        // Remove the source component from the parent. This should cause the signal to emit `None`.
-        app.world_mut().entity_mut(parent).remove::<SourceComponent>();
-        app.update();
-        assert!(
-            app.world().get::<TargetComponent>(child_from_parent).is_none(),
-            "Child's component should be removed when parent's source component is removed."
-        );
-
-        // Re-add the source component to the parent.
-        app.world_mut()
-            .entity_mut(parent)
-            .insert(SourceComponent("Parent Restored".to_string()));
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(child_from_parent),
-            Some(&TargetComponent("Parent Restored".to_string())),
-            "Child's component should be re-added when parent's source component is re-added."
-        );
-
-        // --- 6. Test Failure (Invalid Ancestor) ---
-        // Create a top-level builder (no parent) that asks for an ancestor.
-        // The signal chain should terminate gracefully.
-        let top_level_child = JonmoBuilder::new()
-            .component_signal_from_ancestor(1, signal_factory)
-            .spawn(app.world_mut());
-
-        app.update();
-        assert!(
-            app.world().get::<TargetComponent>(top_level_child).is_none(),
-            "Top-level child should not have target component when asking for a non-existent parent."
-        );
-
-        // --- 7. Test Automatic Cleanup ---
-        // Despawn the child entity.
-        app.world_mut().entity_mut(child_from_parent).despawn();
-        app.update(); // Process the despawn command.
-
-        // Verify it's gone.
-        assert!(
-            app.world().get_entity(child_from_parent).is_err(),
-            "Child entity should be despawned."
-        );
-
-        // Mutate the parent's component again. If the signal was not cleaned up,
-        // this could panic when trying to access the despawned child.
-        app.world_mut().get_mut::<SourceComponent>(parent).unwrap().0 = "Post-Despawn Update".to_string();
-        app.update();
-
-        // The test passes if the previous update didn't panic.
-    }
-
-    #[test]
-    fn test_component_signal_from_parent() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // The factory closure defines the reusable signal logic.
-        // It takes a signal of a parent's entity, gets its `SourceComponent`,
-        // and maps it to an `Option<TargetComponent>`.
-        let signal_factory = |parent_signal: crate::signal::Map<crate::signal::Source<Entity>, Entity>| {
-            parent_signal
-                // Map the parent entity to its `SourceComponent`.
-                .map(|In(entity): In<Entity>, query: Query<&SourceComponent>| query.get(entity).ok().cloned()) // Map the `Option<SourceComponent>` to `Option<TargetComponent>`.
-                .map_in(|opt_source: Option<SourceComponent>| opt_source.map(|source| TargetComponent(source.0)))
-                .dedupe()
-        };
-
-        // Create a parent-child hierarchy.
-        let parent = app.world_mut().spawn(SourceComponent("Parent Data".to_string())).id();
-
-        // --- 2. Test Basic Functionality ---
-        let child = JonmoBuilder::new()
-            .component_signal_from_parent(signal_factory)
-            .spawn(app.world_mut());
-        app.world_mut().entity_mut(parent).add_child(child);
-
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(child),
-            Some(&TargetComponent("Parent Data".to_string())),
-            "Child should get component from its direct parent."
-        );
-
-        // --- 3. Test Reactivity (Update, Remove, Re-add) ---
-        // Update the parent's source component.
-        app.world_mut().get_mut::<SourceComponent>(parent).unwrap().0 = "Parent Updated".to_string();
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(child),
-            Some(&TargetComponent("Parent Updated".to_string())),
-            "Child's component should update when parent's component changes."
-        );
-
-        // Remove the source component from the parent.
-        app.world_mut().entity_mut(parent).remove::<SourceComponent>();
-        app.update();
-        assert!(
-            app.world().get::<TargetComponent>(child).is_none(),
-            "Child's component should be removed when parent's source component is removed."
-        );
-
-        // Re-add the source component to the parent.
-        app.world_mut()
-            .entity_mut(parent)
-            .insert(SourceComponent("Parent Restored".to_string()));
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(child),
-            Some(&TargetComponent("Parent Restored".to_string())),
-            "Child's component should be re-added when parent's source component is re-added."
-        );
-
-        // --- 4. Test Failure Case (No Parent) ---
-        // Create a top-level builder (no parent). The signal should not run.
-        let top_level_child = JonmoBuilder::new()
-            .component_signal_from_parent(signal_factory)
-            .spawn(app.world_mut());
-
-        app.update();
-        assert!(
-            app.world().get::<TargetComponent>(top_level_child).is_none(),
-            "Top-level child should not have target component as it has no parent."
-        );
-
-        // --- 5. Test Automatic Cleanup ---
-        // Despawn the child entity.
-        app.world_mut().entity_mut(child).despawn();
-        app.update(); // Process the despawn command.
-
-        // Verify it's gone.
-        assert!(
-            app.world().get_entity(child).is_err(),
-            "Child entity should be despawned."
-        );
-
-        // Mutate the parent's component again. If the signal was not cleaned up,
-        // this could panic when trying to access the despawned child.
-        app.world_mut().get_mut::<SourceComponent>(parent).unwrap().0 = "Post-Despawn Update".to_string();
-        app.update();
-
-        // The test passes if the previous update didn't panic.
-    }
-
-    #[test]
-    fn test_component_signal_from_component() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // The component that acts as the data source for the signal.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct SourceComponent(i32);
-
-        // The component that will be reactively managed by the signal's output.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TargetComponent(String);
-
-        // The factory closure that defines the signal logic.
-        // It receives a signal of the `SourceComponent` and transforms its value
-        // into an `Option<TargetComponent>`.
-        let signal_factory = |source_signal: crate::signal::Map<crate::signal::Source<Entity>, SourceComponent>| {
-            source_signal
-                // The signal from `component_signal_from_component` is already deduplicated
-                // by the `Changed<C>` filter in its upstream `signal_from_component_changed`,
-                // but adding one here is a good practice for robustness.
-                .dedupe()
-                // Map the source value to the target component's value.
-                .map_in(|source: SourceComponent| TargetComponent(format!("Value is {}", source.0)))
-                // The final signal must produce an `Option`.
-                .map_in(Some)
-        };
-
-        // --- 2. Test Initial State & Reactivity ---
-        let builder1 = JonmoBuilder::new()
-            .insert(SourceComponent(10))
-            .component_signal_from_component(signal_factory);
-
-        let entity1 = builder1.spawn(app.world_mut());
-
-        // Frame 1: The `SourceComponent` is newly added, which counts as `Changed`.
-        // The signal should fire and insert the `TargetComponent`.
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Value is 10".to_string())),
-            "TargetComponent should be inserted on initial spawn."
-        );
-
-        // Frame 2: No change to `SourceComponent`. The signal should not fire again.
-        // We can test this by trying to remove the TargetComponent and seeing if it
-        // gets re-added. It should not.
-        app.world_mut().entity_mut(entity1).remove::<TargetComponent>();
-        app.update();
-        assert!(
-            app.world().get::<TargetComponent>(entity1).is_none(),
-            "TargetComponent should not be re-inserted on an unchanged frame."
-        );
-
-        // Frame 3: Mutate the `SourceComponent`. The signal should fire and update the
-        // `TargetComponent`.
-        app.world_mut().get_mut::<SourceComponent>(entity1).unwrap().0 = 20;
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Value is 20".to_string())),
-            "TargetComponent should be updated after SourceComponent changes."
-        );
-
-        // --- 3. Test Failure Case: No SourceComponent ---
-        // Spawn an entity with the signal but without the `SourceComponent`.
-        // The signal chain should terminate gracefully and not insert the `TargetComponent`.
-        let builder_no_source = JonmoBuilder::new().component_signal_from_component(signal_factory);
-        let entity_no_source = builder_no_source.spawn(app.world_mut());
-
-        app.update();
-        assert!(
-            app.world().get::<TargetComponent>(entity_no_source).is_none(),
-            "TargetComponent should not be inserted if SourceComponent is missing."
-        );
-
-        // --- 4. Test Multi-Entity Independence ---
-        let builder2 = JonmoBuilder::new()
-            .insert(SourceComponent(100))
-            .component_signal_from_component(signal_factory);
-        let entity2 = builder2.spawn(app.world_mut());
-
-        // Frame 4: Update both entities.
-        app.world_mut().get_mut::<SourceComponent>(entity1).unwrap().0 = 30;
-        // The update for entity2 happens implicitly on spawn.
-        app.update();
-
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Value is 30".to_string())),
-            "Entity 1 failed to update in multi-entity test."
-        );
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity2),
-            Some(&TargetComponent("Value is 100".to_string())),
-            "Entity 2 failed to initialize in multi-entity test."
-        );
-
-        // --- 5. Test Automatic Cleanup ---
-        app.world_mut().entity_mut(entity1).despawn();
-        app.update(); // Process despawn command.
-
-        // Mutate the `SourceComponent` of the remaining entity.
-        app.world_mut().get_mut::<SourceComponent>(entity2).unwrap().0 = 200;
-        app.update();
-
-        // The test passes if the app doesn't panic. We also verify the state.
-        assert!(
-            app.world().get_entity(entity1).is_err(),
-            "Despawned entity should not exist."
-        );
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity2),
-            Some(&TargetComponent("Value is 200".to_string())),
-            "Remaining entity failed to update after other was despawned."
-        );
-    }
-
-    #[test]
-    fn test_component_signal_from_component_option() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // The factory closure defines the signal logic. It receives a signal that
-        // *always* emits an `Option<SourceComponent>`. This is the key difference
-        // from `component_signal_from_component`.
-        let signal_factory =
-            |source_opt_signal: crate::signal::Map<crate::signal::Source<Entity>, Option<SourceComponent>>| {
-                source_opt_signal
-                    .dedupe()
-                    // Map the Option<SourceComponent> to an Option<TargetComponent>.
-                    // This logic explicitly handles both the Some and None cases.
-                    .map_in(|opt_source: Option<SourceComponent>| match opt_source {
-                        // If the source exists, create a target component with its data.
-                        Some(source) => Some(TargetComponent(format!("Source: {}", source.0))),
-                        // If the source is missing, create a target component with a default value.
-                        None => Some(TargetComponent("Source: None".to_string())),
-                    })
-            };
-
-        // --- 2. Test Case: Source Component is PRESENT ---
-        let builder_with_comp = JonmoBuilder::new()
-            .insert(SourceComponent("Data A".to_string()))
-            .component_signal_from_component_option(signal_factory);
-
-        let entity_with_comp = builder_with_comp.spawn(app.world_mut());
-        app.update();
-
-        // The factory should have received `Some(SourceComponent)` and produced the corresponding
-        // target.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity_with_comp),
-            Some(&TargetComponent("Source: Data A".to_string())),
-            "TargetComponent should be created from the present SourceComponent."
-        );
-
-        // --- 3. Test Case: Source Component is MISSING ---
-        // This is the primary test for this function's unique behavior.
-        let builder_without_comp = JonmoBuilder::new().component_signal_from_component_option(signal_factory);
-
-        let entity_without_comp = builder_without_comp.spawn(app.world_mut());
-        app.update();
-
-        // The factory should have received `None` and produced the default target.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity_without_comp),
-            Some(&TargetComponent("Source: None".to_string())),
-            "TargetComponent should be created from the missing SourceComponent (None path)."
-        );
-
-        // --- 4. Test Reactivity of Component PRESENCE ---
-        // We will use `entity_with_comp` for this test.
-
-        // Step 4a: Remove the source component. The signal should re-run and update the target.
-        app.world_mut().entity_mut(entity_with_comp).remove::<SourceComponent>();
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity_with_comp),
-            Some(&TargetComponent("Source: None".to_string())),
-            "TargetComponent should update to 'None' state after source is removed."
-        );
-
-        // Step 4b: Re-add the source component. The signal should re-run again.
-        app.world_mut()
-            .entity_mut(entity_with_comp)
-            .insert(SourceComponent("Data B".to_string()));
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity_with_comp),
-            Some(&TargetComponent("Source: Data B".to_string())),
-            "TargetComponent should update after source is re-added."
-        );
-
-        // Step 4c: No change frame. Due to `.dedupe()`, the signal should not cause a write.
-        // (This is harder to assert directly, but is an implicit part of the logic).
-        app.update(); // Run again without changes.
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity_with_comp),
-            Some(&TargetComponent("Source: Data B".to_string())),
-            "TargetComponent should remain unchanged on a no-op frame."
-        );
-
-        // --- 5. Test Automatic Cleanup ---
-        app.world_mut().entity_mut(entity_with_comp).despawn();
-        app.update();
-
-        assert!(
-            app.world().get_entity(entity_with_comp).is_err(),
-            "Entity should be despawned."
-        );
-
-        // The test passes if the app doesn't panic on subsequent updates, proving
-        // the signal isn't trying to access a despawned entity.
-        app.update();
-    }
-
-    #[test]
-    fn test_component_signal_from_component_changed() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // The component that acts as the data source for the signal.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct SourceComponent(i32);
-
-        // The component that will be reactively managed by the signal's output.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TargetComponent(String);
-
-        // The factory closure that defines the signal logic.
-        // It receives a signal of the `SourceComponent` (only on changed frames)
-        // and transforms its value into an `Option<TargetComponent>`.
-        let signal_factory = |source_signal: crate::signal::Map<crate::signal::Source<Entity>, SourceComponent>| {
-            source_signal
-                // Map the source value to the target component's value.
-                .map_in(|source: SourceComponent| TargetComponent(format!("Value is {}", source.0)))
-                // The final signal must produce an `Option`.
-                .map_in(Some)
-        };
-
-        // --- 2. Test Initial State & Reactivity on Changed Frames ---
-        let builder1 = JonmoBuilder::new()
-            .insert(SourceComponent(10))
-            .component_signal_from_component_changed(signal_factory);
-
-        let entity1 = builder1.spawn(app.world_mut());
-
-        // Frame 1: The `SourceComponent` is newly added, which counts as `Changed`.
-        // The signal should fire and insert the `TargetComponent`.
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Value is 10".to_string())),
-            "TargetComponent should be inserted on initial spawn."
-        );
-
-        // Frame 2: No change to `SourceComponent`. The signal should not fire.
-        // Remove the TargetComponent to verify it doesn't get re-added.
-        app.world_mut().entity_mut(entity1).remove::<TargetComponent>();
-        app.update();
-        assert!(
-            app.world().get::<TargetComponent>(entity1).is_none(),
-            "TargetComponent should not be re-inserted on an unchanged frame."
-        );
-
-        // Frame 3: Mutate the `SourceComponent`. The signal should fire and update the
-        // `TargetComponent`.
-        app.world_mut().get_mut::<SourceComponent>(entity1).unwrap().0 = 20;
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Value is 20".to_string())),
-            "TargetComponent should be updated after SourceComponent changes."
-        );
-
-        // Frame 4: Mutate again to verify continued reactivity.
-        app.world_mut().get_mut::<SourceComponent>(entity1).unwrap().0 = 30;
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Value is 30".to_string())),
-            "TargetComponent should be updated on subsequent changes."
-        );
-
-        // --- 3. Test Failure Case: No SourceComponent ---
-        // Spawn an entity with the signal but without the `SourceComponent`.
-        // The signal chain should terminate gracefully and not insert the `TargetComponent`.
-        let builder_no_source = JonmoBuilder::new().component_signal_from_component_changed(signal_factory);
-        let entity_no_source = builder_no_source.spawn(app.world_mut());
-
-        app.update();
-        assert!(
-            app.world().get::<TargetComponent>(entity_no_source).is_none(),
-            "TargetComponent should not be inserted if SourceComponent is missing."
-        );
-
-        // Add the SourceComponent later and verify the signal starts working.
-        app.world_mut()
-            .entity_mut(entity_no_source)
-            .insert(SourceComponent(100));
-        app.update();
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity_no_source),
-            Some(&TargetComponent("Value is 100".to_string())),
-            "TargetComponent should be inserted after SourceComponent is added."
-        );
-
-        // --- 4. Test Multi-Entity Independence ---
-        let builder2 = JonmoBuilder::new()
-            .insert(SourceComponent(200))
-            .component_signal_from_component_changed(signal_factory);
-        let entity2 = builder2.spawn(app.world_mut());
-
-        // Frame: Update entity2 (on spawn) and entity1 (manual change).
-        app.world_mut().get_mut::<SourceComponent>(entity1).unwrap().0 = 40;
-        app.update();
-
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity1),
-            Some(&TargetComponent("Value is 40".to_string())),
-            "Entity 1 failed to update in multi-entity test."
-        );
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity2),
-            Some(&TargetComponent("Value is 200".to_string())),
-            "Entity 2 failed to initialize in multi-entity test."
-        );
-
-        // --- 5. Test Automatic Cleanup ---
-        app.world_mut().entity_mut(entity1).despawn();
-        app.update(); // Process despawn command.
-
-        // Mutate the `SourceComponent` of the remaining entities.
-        app.world_mut().get_mut::<SourceComponent>(entity2).unwrap().0 = 300;
-        app.world_mut().get_mut::<SourceComponent>(entity_no_source).unwrap().0 = 150;
-        app.update();
-
-        // The test passes if the app doesn't panic. We also verify the state.
-        assert!(
-            app.world().get_entity(entity1).is_err(),
-            "Despawned entity should not exist."
-        );
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity2),
-            Some(&TargetComponent("Value is 300".to_string())),
-            "Entity 2 failed to update after entity1 was despawned."
-        );
-        assert_eq!(
-            app.world().get::<TargetComponent>(entity_no_source),
-            Some(&TargetComponent("Value is 150".to_string())),
-            "Entity no_source failed to update after entity1 was despawned."
-        );
-    }
-
-    #[test]
-    fn test_child() {
-        {
-            // --- 1. Setup ---
-            let mut app = create_test_app();
+    fn test_child() {
+        {
+            // --- 1. Setup ---
+            let mut app = create_test_app();
 
             // Marker components for identifying entities
             #[derive(Component, Debug, PartialEq)]
@@ -2720,8 +1011,8 @@ mod tests {
             struct TargetComp(i32);
 
             // --- 2. Test: Simple Parent-Child Relationship ---
-            let child_builder_simple = JonmoBuilder::new().insert((ChildCompA, Name::new("SimpleChild")));
-            let parent_builder_simple = JonmoBuilder::new().insert(ParentComp).child(child_builder_simple);
+            let child_builder_simple = jonmo::Builder::new().insert((ChildCompA, Name::new("SimpleChild")));
+            let parent_builder_simple = jonmo::Builder::new().insert(ParentComp).child(child_builder_simple);
 
             let parent_entity_simple = parent_builder_simple.spawn(app.world_mut());
             app.update();
@@ -2746,10 +1037,10 @@ mod tests {
             app.update();
 
             // --- 3. Test: Multiple Chained Children & Correct Order ---
-            let parent_builder_chained = JonmoBuilder::new()
+            let parent_builder_chained = jonmo::Builder::new()
                 .insert(ParentComp)
-                .child(JonmoBuilder::new().insert(ChildCompA))
-                .child(JonmoBuilder::new().insert(ChildCompB));
+                .child(jonmo::Builder::new().insert(ChildCompA))
+                .child(jonmo::Builder::new().insert(ChildCompB));
 
             let parent_entity_chained = parent_builder_chained.spawn(app.world_mut());
             app.update();
@@ -2774,9 +1065,11 @@ mod tests {
             app.update();
 
             // --- 4. Test: Nested Hierarchy ---
-            let grandchild_builder = JonmoBuilder::new().insert(Name::new("Grandchild"));
-            let child_builder_nested = JonmoBuilder::new().insert(Name::new("Child")).child(grandchild_builder);
-            let grandparent_builder = JonmoBuilder::new()
+            let grandchild_builder = jonmo::Builder::new().insert(Name::new("Grandchild"));
+            let child_builder_nested = jonmo::Builder::new()
+                .insert(Name::new("Child"))
+                .child(grandchild_builder);
+            let grandparent_builder = jonmo::Builder::new()
                 .insert(Name::new("Grandparent"))
                 .child(child_builder_nested);
 
@@ -2805,21 +1098,24 @@ mod tests {
             struct SignalTrigger(bool);
             app.init_resource::<SignalTrigger>();
 
-            let child_a = JonmoBuilder::new().insert(ChildCompA);
-            let child_b = JonmoBuilder::new().insert(ChildCompB);
-            let child_c = JonmoBuilder::new().insert(ChildCompC);
-            let child_d = JonmoBuilder::new().insert(ChildCompD);
-            let child_e = JonmoBuilder::new().insert(ChildCompE);
+            let child_a = jonmo::Builder::new().insert(ChildCompA);
+            let child_b = jonmo::Builder::new().insert(ChildCompB);
+            let child_c = jonmo::Builder::new().insert(ChildCompC);
+            let child_d = jonmo::Builder::new().insert(ChildCompD);
+            // Use a factory function instead of cloning
+            fn make_child_e() -> jonmo::Builder {
+                jonmo::Builder::new().insert(ChildCompE)
+            }
 
-            let parent_builder_mixed = JonmoBuilder::new()
+            let parent_builder_mixed = jonmo::Builder::new()
                 .insert(ParentComp)
                 .child(child_a) // Block 0, offset 0
-                .children([child_b.clone(), child_c.clone()]) // Block 1, offset 1
+                .children([child_b, child_c]) // Block 1, offset 1
                 .child(child_d) // Block 2, offset 3
                 .child_signal(
                     // Block 3, offset 4
-                    SignalBuilder::from_resource::<SignalTrigger>().map_in::<Option<JonmoBuilder>, _, _>(
-                        move |trigger: SignalTrigger| if trigger.0 { Some(child_e.clone()) } else { None },
+                    signal::from_resource::<SignalTrigger>().map_in::<Option<Builder>, _, _>(
+                        move |trigger: SignalTrigger| if trigger.0 { Some(make_child_e()) } else { None },
                     ),
                 );
 
@@ -2859,13 +1155,24 @@ mod tests {
             app.update();
 
             // --- 6. Test: Child's Signals Function Correctly ---
-            let child_builder_with_signal = JonmoBuilder::new().component_signal_from_parent(|parent_signal| {
-                parent_signal
+            // Use LazyEntity + signal::Builder pattern instead of removed component_signal_from_parent
+            let child_entity = LazyEntity::new();
+            let child_builder_with_signal = jonmo::Builder::new().lazy_entity(child_entity.clone()).on_signal(
+                signal::from_parent_lazy(child_entity.clone())
                     .component::<SourceComp>()
-                    .map_in(|source: SourceComp| Some(TargetComp(source.0 * 2)))
-            });
+                    .map_in(|source: SourceComp| Some(TargetComp(source.0 * 2))),
+                |In((entity, comp_opt)): In<(Entity, Option<TargetComp>)>, world: &mut World| {
+                    if let Ok(mut e) = world.get_entity_mut(entity) {
+                        if let Some(comp) = comp_opt {
+                            e.insert(comp);
+                        } else {
+                            e.remove::<TargetComp>();
+                        }
+                    }
+                },
+            );
 
-            let parent_builder_with_signal = JonmoBuilder::new()
+            let parent_builder_with_signal = jonmo::Builder::new()
                 .insert(SourceComp(10))
                 .child(child_builder_with_signal);
 
@@ -2945,20 +1252,20 @@ mod tests {
             app.init_resource::<SignalSource>();
 
             // A factory function to create reactive child builders based on a number
-            let reactive_child_factory = |id: u32| JonmoBuilder::new().insert(ReactiveChild(id));
+            let reactive_child_factory = |id: u32| jonmo::Builder::new().insert(ReactiveChild(id));
 
-            // The signal that maps the resource to an Option<JonmoBuilder>
-            let source_signal = SignalBuilder::from_resource::<SignalSource>()
+            // The signal that maps the resource to an Option<jonmo::Builder>
+            let source_signal = signal::from_resource::<SignalSource>()
                 .dedupe()
                 .map_in(move |source: SignalSource| source.0.map(reactive_child_factory));
 
             // --- 2. Build the Parent Entity ---
             // This builder has static children sandwiching the reactive one to test ordering.
-            let parent_builder = JonmoBuilder::new()
+            let parent_builder = jonmo::Builder::new()
                 .insert(ParentComp)
-                .child(JonmoBuilder::new().insert(StaticChildBefore)) // Child in block 0
+                .child(jonmo::Builder::new().insert(StaticChildBefore)) // Child in block 0
                 .child_signal(source_signal) // Child in block 1
-                .child(JonmoBuilder::new().insert(StaticChildAfter)); // Child in block 2
+                .child(jonmo::Builder::new().insert(StaticChildAfter)); // Child in block 2
 
             let parent_entity = parent_builder.spawn(app.world_mut());
 
@@ -3105,11 +1412,11 @@ mod tests {
             // specified order.
             {
                 let child_builders = vec![
-                    JonmoBuilder::new().insert(ChildCompA),
-                    JonmoBuilder::new().insert(ChildCompB),
-                    JonmoBuilder::new().insert(ChildCompC),
+                    jonmo::Builder::new().insert(ChildCompA),
+                    jonmo::Builder::new().insert(ChildCompB),
+                    jonmo::Builder::new().insert(ChildCompC),
                 ];
-                let parent_builder = JonmoBuilder::new().insert(ParentComp).children(child_builders);
+                let parent_builder = jonmo::Builder::new().insert(ParentComp).children(child_builders);
 
                 let parent_entity = parent_builder.spawn(app.world_mut());
                 app.update();
@@ -3153,9 +1460,9 @@ mod tests {
             // Verifies that providing an empty iterator results in no children being added.
             {
                 // The type hint is needed for an empty vec.
-                let parent_builder_empty = JonmoBuilder::new()
+                let parent_builder_empty = jonmo::Builder::new()
                     .insert(ParentComp)
-                    .children(vec![] as Vec<JonmoBuilder>);
+                    .children(vec![] as Vec<Builder>);
                 let parent_entity_empty = parent_builder_empty.spawn(app.world_mut());
                 app.update();
                 assert!(
@@ -3171,17 +1478,28 @@ mod tests {
             // Verifies that children can have their own complex logic (signals, hierarchy) and that
             // they are properly cleaned up when the parent is despawned.
             {
-                let complex_child_builder = JonmoBuilder::new()
+                // Use LazyEntity + signal::Builder pattern instead of removed component_signal_from_parent
+                let complex_child_entity = LazyEntity::new();
+                let complex_child_builder = jonmo::Builder::new()
+                    .lazy_entity(complex_child_entity.clone())
                     .insert(ChildCompD)
-                    .child(JonmoBuilder::new().insert(GrandchildComp)) // Nested child
-                    .component_signal_from_parent(|parent_signal| {
-                        // Signal reading from parent
-                        parent_signal
+                    .child(jonmo::Builder::new().insert(GrandchildComp)) // Nested child
+                    .on_signal(
+                        signal::from_parent_lazy(complex_child_entity.clone())
                             .component::<SourceComp>()
-                            .map_in(|source: SourceComp| Some(TargetComp(source.0 * 10)))
-                    });
+                            .map_in(|source: SourceComp| Some(TargetComp(source.0 * 10))),
+                        |In((entity, comp_opt)): In<(Entity, Option<TargetComp>)>, world: &mut World| {
+                            if let Ok(mut e) = world.get_entity_mut(entity) {
+                                if let Some(comp) = comp_opt {
+                                    e.insert(comp);
+                                } else {
+                                    e.remove::<TargetComp>();
+                                }
+                            }
+                        },
+                    );
 
-                let parent_builder_complex = JonmoBuilder::new()
+                let parent_builder_complex = jonmo::Builder::new()
                     .insert((ParentComp, SourceComp(5)))
                     .children(vec![complex_child_builder]);
 
@@ -3189,23 +1507,23 @@ mod tests {
                 app.update();
 
                 let complex_children = app.world().get::<Children>(parent_entity_complex).unwrap();
-                let complex_child_entity = complex_children[0];
+                let complex_child_entity_id = complex_children[0];
 
                 // Verify signal ran correctly
                 assert_eq!(
-                    app.world().get::<TargetComp>(complex_child_entity),
+                    app.world().get::<TargetComp>(complex_child_entity_id),
                     Some(&TargetComp(50))
                 );
 
                 // Verify nested hierarchy
-                let grandchild_entity = app.world().get::<Children>(complex_child_entity).unwrap()[0];
+                let grandchild_entity = app.world().get::<Children>(complex_child_entity_id).unwrap()[0];
                 assert!(app.world().entity(grandchild_entity).contains::<GrandchildComp>());
 
                 // Test reactivity
                 app.world_mut().get_mut::<SourceComp>(parent_entity_complex).unwrap().0 = 7;
                 app.update();
                 assert_eq!(
-                    app.world().get::<TargetComp>(complex_child_entity),
+                    app.world().get::<TargetComp>(complex_child_entity_id),
                     Some(&TargetComp(70)),
                     "Signal did not react to parent's component change."
                 );
@@ -3215,7 +1533,7 @@ mod tests {
                 app.update();
 
                 assert!(
-                    app.world().get_entity(complex_child_entity).is_err(),
+                    app.world().get_entity(complex_child_entity_id).is_err(),
                     "Complex child should be despawned with parent."
                 );
                 assert!(
@@ -3264,19 +1582,19 @@ mod tests {
                 struct SignalTrigger(bool);
                 app.init_resource::<SignalTrigger>();
 
-                let parent_builder = JonmoBuilder::new()
+                let parent_builder = jonmo::Builder::new()
                     .insert(ParentComp)
-                    .child(JonmoBuilder::new().insert(ChildCompA)) // Block 0, size 1
+                    .child(jonmo::Builder::new().insert(ChildCompA)) // Block 0, size 1
                     .children([
                         // Block 1, size 2
-                        JonmoBuilder::new().insert(ChildCompB),
-                        JonmoBuilder::new().insert(ChildCompC),
+                        jonmo::Builder::new().insert(ChildCompB),
+                        jonmo::Builder::new().insert(ChildCompC),
                     ])
                     .child_signal(
                         // Block 2, size 0 -> 1
-                        SignalBuilder::from_resource::<SignalTrigger>().map_in(|trigger: SignalTrigger| {
+                        signal::from_resource::<SignalTrigger>().map_in(|trigger: SignalTrigger| {
                             if trigger.0 {
-                                Some(JonmoBuilder::new().insert(ChildCompD))
+                                Some(jonmo::Builder::new().insert(ChildCompD))
                             } else {
                                 None
                             }
@@ -3284,11 +1602,11 @@ mod tests {
                     )
                     .children(vec![
                         // Block 3, size 3
-                        JonmoBuilder::new().insert(ChildCompE),
-                        JonmoBuilder::new().insert(ChildCompF),
-                        JonmoBuilder::new().insert(ChildCompG),
+                        jonmo::Builder::new().insert(ChildCompE),
+                        jonmo::Builder::new().insert(ChildCompF),
+                        jonmo::Builder::new().insert(ChildCompG),
                     ])
-                    .child(JonmoBuilder::new().insert(ChildCompH)); // Block 4, size 1
+                    .child(jonmo::Builder::new().insert(ChildCompH)); // Block 4, size 1
 
                 let parent_entity = parent_builder.spawn(app.world_mut());
 
@@ -3362,20 +1680,20 @@ mod tests {
         {
             // --- 1. SETUP ---
             let mut app = create_test_app();
-            let source_vec = MutableVecBuilder::from([10u32, 20u32]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([10u32, 20u32]).spawn(app.world_mut());
 
-            // A factory function to create a simple JonmoBuilder for a reactive child.
-            let child_builder_factory = |id: u32| JonmoBuilder::new().insert(ReactiveChild(id));
+            // A factory function to create a simple jonmo::Builder for a reactive child.
+            let child_builder_factory = |id: u32| jonmo::Builder::new().insert(ReactiveChild(id));
 
             // The SignalVec that will drive the children.
             let children_signal = source_vec.signal_vec().map_in(child_builder_factory);
 
             // The parent builder, with static children sandwiching the reactive ones to test ordering.
-            let parent_builder = JonmoBuilder::new()
+            let parent_builder = jonmo::Builder::new()
                 .insert(ParentComp)
-                .child(JonmoBuilder::new().insert(StaticChildBefore))
+                .child(jonmo::Builder::new().insert(StaticChildBefore))
                 .children_signal_vec(children_signal)
-                .child(JonmoBuilder::new().insert(StaticChildAfter));
+                .child(jonmo::Builder::new().insert(StaticChildAfter));
 
             let parent_entity = parent_builder.spawn(app.world_mut());
 
@@ -3558,7 +1876,7 @@ mod tests {
 
         // --- 2. Test Basic Callback Execution ---
         let tracker = app.world().resource::<DespawnTracker>().clone();
-        let builder1 = JonmoBuilder::new().on_despawn({
+        let builder1 = jonmo::Builder::new().on_despawn({
             let tracker = tracker.clone();
             move |_world, entity| {
                 tracker.0.lock().unwrap().push((entity, "callback1".to_string()));
@@ -3586,7 +1904,7 @@ mod tests {
         tracker.0.lock().unwrap().clear();
 
         // --- 3. Test Multiple Callbacks on Same Entity ---
-        let builder2 = JonmoBuilder::new()
+        let builder2 = jonmo::Builder::new()
             .on_despawn({
                 let tracker = tracker.clone();
                 move |_world, entity| {
@@ -3624,7 +1942,7 @@ mod tests {
         tracker.0.lock().unwrap().clear();
 
         // --- 4. Test Multi-Entity Independence ---
-        let builder3 = JonmoBuilder::new().on_despawn({
+        let builder3 = jonmo::Builder::new().on_despawn({
             let tracker = tracker.clone();
             move |_world, entity| {
                 tracker.0.lock().unwrap().push((entity, "entity3".to_string()));
@@ -3632,7 +1950,7 @@ mod tests {
         });
         let entity3 = builder3.spawn(app.world_mut());
 
-        let builder4 = JonmoBuilder::new().on_despawn({
+        let builder4 = jonmo::Builder::new().on_despawn({
             let tracker = tracker.clone();
             move |_world, entity| {
                 tracker.0.lock().unwrap().push((entity, "entity4".to_string()));
@@ -3670,7 +1988,7 @@ mod tests {
 
         app.init_resource::<DespawnCounter>();
 
-        let builder5 = JonmoBuilder::new().on_despawn(|world, _entity| {
+        let builder5 = jonmo::Builder::new().on_despawn(|world, _entity| {
             world.resource_mut::<DespawnCounter>().0 += 1;
         });
 
@@ -3693,7 +2011,7 @@ mod tests {
         );
 
         // Spawn and despawn another entity to verify counter increments again.
-        let builder6 = JonmoBuilder::new().on_despawn(|world, _entity| {
+        let builder6 = jonmo::Builder::new().on_despawn(|world, _entity| {
             world.resource_mut::<DespawnCounter>().0 += 10;
         });
         let entity6 = builder6.spawn(app.world_mut());
@@ -3718,12 +2036,12 @@ mod tests {
         let child_tracker = child_despawn_tracker.clone();
         let parent_tracker = parent_despawn_tracker.clone();
 
-        let builder_parent = JonmoBuilder::new()
+        let builder_parent = jonmo::Builder::new()
             .insert(TestMarker)
             .on_despawn(move |_world, entity| {
                 parent_tracker.lock().unwrap().push(entity);
             })
-            .child(JonmoBuilder::new().on_despawn(move |_world, entity| {
+            .child(jonmo::Builder::new().on_despawn(move |_world, entity| {
                 child_tracker.lock().unwrap().push(entity);
             }));
 
diff --git a/src/graph.rs b/src/graph.rs
index 7bced66..38a4e68 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -121,21 +121,22 @@ pub(crate) fn pipe_signal(world: &mut World, source: SignalSystem, target: Signa
         error!("cycle detected when attempting to pipe {:?} → {:?}", source, target);
         return;
     }
-    if let Ok(mut upstream) = world.get_entity_mut(*source) {
-        if let Some(mut downstream) = upstream.get_mut::<Downstream>() {
-            downstream.0.insert(target);
-        } else {
-            upstream.insert(Downstream(HashSet::from([target])));
-        }
-    }
-    if let Ok(mut downstream) = world.get_entity_mut(*target) {
-        if let Some(mut upstream) = downstream.get_mut::<Upstream>() {
-            upstream.0.insert(source);
-        } else {
-            downstream.insert(Upstream(HashSet::from([source])));
-        }
+    let mut upstream = world.entity_mut(*source);
+    if let Some(mut downstream) = upstream.get_mut::<Downstream>() {
+        downstream.0.insert(target);
+    } else {
+        upstream.insert(Downstream(HashSet::from([target])));
+    }
+    let mut downstream = world.entity_mut(*target);
+    if let Some(mut upstream) = downstream.get_mut::<Upstream>() {
+        upstream.0.insert(source);
+    } else {
+        downstream.insert(Upstream(HashSet::from([source])));
     }
-    world.resource_mut::<SignalGraphState>().edge_change_seeds.insert(target);
+    world
+        .resource_mut::<SignalGraphState>()
+        .edge_change_seeds
+        .insert(target);
 }
 
 #[derive(Component, Clone)]
@@ -200,7 +201,6 @@ clone_trait_object!(AnyClone);
 
 impl<T: Clone + 'static> AnyClone for T {}
 
-
 /// Tracks signal graph topology for level-based processing.
 #[derive(Resource, Default)]
 pub(crate) struct SignalGraphState {
@@ -216,7 +216,8 @@ pub(crate) struct SignalGraphState {
     is_processing: bool,
 }
 
-// Fan out a signal output to downstream input queues. When there is exactly one downstream, move the value without cloning.
+// Fan out a signal output to downstream input queues. When there is exactly one downstream, move
+// the value without cloning.
 fn enqueue_inputs(
     world: &World,
     inputs: &mut HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>>,
@@ -230,19 +231,13 @@ fn enqueue_inputs(
 
     if downstreams.len() == 1 {
         // avoid cloning if there's only a single downstream
-        inputs
-            .entry(downstreams[0])
-            .or_default()
-            .push_back(value);
+        inputs.entry(downstreams[0]).or_default().push_back(value);
         return;
     }
 
     if let Some((last, rest)) = downstreams.split_last() {
         for downstream in rest {
-            inputs
-                .entry(*downstream)
-                .or_default()
-                .push_back(value.clone());
+            inputs.entry(*downstream).or_default().push_back(value.clone());
         }
         inputs.entry(*last).or_default().push_back(value);
     }
@@ -263,13 +258,11 @@ fn get_downstreams(world: &World, signal: SignalSystem) -> Vec<SignalSystem> {
 }
 
 fn insert_sorted_by_index(bucket: &mut Vec<SignalSystem>, signal: SignalSystem) {
-    if bucket.iter().any(|s| *s == signal) {
+    if bucket.contains(&signal) {
         return;
     }
     let key = signal.index();
-    let index = bucket
-        .binary_search_by_key(&key, |s| s.index())
-        .unwrap_or_else(|i| i);
+    let index = bucket.binary_search_by_key(&key, |s| s.index()).unwrap_or_else(|i| i);
     bucket.insert(index, signal);
 }
 
@@ -277,10 +270,7 @@ fn insert_sorted_by_index(bucket: &mut Vec<SignalSystem>, signal: SignalSystem)
 // from `seeds`. This intentionally does NOT use `SignalGraphState` because it only
 // needs a lightweight traversal for the provided subset and should not mutate or
 // depend on the global cached topology.
-fn downstream_levels_from_seeds(
-    world: &World,
-    seeds: &[SignalSystem],
-) -> Vec<Vec<SignalSystem>> {
+fn downstream_levels_from_seeds(world: &World, seeds: &[SignalSystem]) -> Vec<Vec<SignalSystem>> {
     let mut levels: HashMap<SignalSystem, u32> = HashMap::new();
     let mut by_level: Vec<HashSet<SignalSystem>> = Vec::new();
     let mut queue: VecDeque<SignalSystem> = VecDeque::new();
@@ -325,19 +315,14 @@ fn downstream_levels_from_seeds(
 // - Roots (in-degree 0) start at level 0.
 // - Each node's level is 1 + max(level of its upstreams).
 // - Nodes are bucketed by level for deterministic per-level iteration.
-// - If a cycle or inconsistent edges are detected (not all nodes processed),
-//   this panics because the graph invariants were violated.
+// - If a cycle or inconsistent edges are detected (not all nodes processed), this panics because
+//   the graph invariants were violated.
 fn rebuild_levels(world: &mut World, state: &mut SignalGraphState) {
     state.levels.clear();
     state.by_level.clear();
 
-    let mut all_signals =
-        SystemState::<Query<Entity, (With<SystemRunner>, Allow<Internal>)>>::new(world);
-    let signals = all_signals
-        .get(world)
-        .iter()
-        .map(SignalSystem)
-        .collect::<Vec<_>>();
+    let mut all_signals = SystemState::<Query<Entity, (With<SystemRunner>, Allow<Internal>)>>::new(world);
+    let signals = all_signals.get(world).iter().map(SignalSystem).collect::<Vec<_>>();
 
     let mut in_degree: HashMap<SignalSystem, usize> = HashMap::new();
     let mut upstreams_map: HashMap<SignalSystem, Vec<SignalSystem>> = HashMap::new();
@@ -419,10 +404,7 @@ fn update_levels_incremental(world: &mut World, state: &mut SignalGraphState) ->
 
     for signal in affected.iter().copied() {
         let upstreams = get_upstreams(world, signal);
-        let local_in_degree = upstreams
-            .iter()
-            .filter(|u| affected.contains(&(**u)))
-            .count();
+        let local_in_degree = upstreams.iter().filter(|u| affected.contains(&(**u))).count();
         in_degree.insert(signal, local_in_degree);
         upstreams_map.insert(signal, upstreams);
     }
@@ -469,12 +451,11 @@ fn update_levels_incremental(world: &mut World, state: &mut SignalGraphState) ->
     }
 
     for signal in affected {
-        if let Some(old_level) = state.levels.get(&signal).copied() {
-            if let Some(bucket) = state.by_level.get_mut(old_level as usize) {
-                if let Some(pos) = bucket.iter().position(|s| *s == signal) {
-                    bucket.remove(pos);
-                }
-            }
+        if let Some(old_level) = state.levels.get(&signal).copied()
+            && let Some(bucket) = state.by_level.get_mut(old_level as usize)
+            && let Some(pos) = bucket.iter().position(|s| *s == signal)
+        {
+            bucket.remove(pos);
         }
 
         if let Some(new_level) = new_levels.get(&signal).copied() {
@@ -509,12 +490,11 @@ fn update_edge_change_levels(world: &mut World, state: &mut SignalGraphState) {
 }
 
 fn remove_signal_from_graph_state_internal(state: &mut SignalGraphState, signal: SignalSystem) {
-    if let Some(level) = state.levels.remove(&signal) {
-        if let Some(bucket) = state.by_level.get_mut(level as usize) {
-            if let Some(pos) = bucket.iter().position(|s| *s == signal) {
-                bucket.remove(pos);
-            }
-        }
+    if let Some(level) = state.levels.remove(&signal)
+        && let Some(bucket) = state.by_level.get_mut(level as usize)
+        && let Some(pos) = bucket.iter().position(|s| *s == signal)
+    {
+        bucket.remove(pos);
     }
     state.edge_change_seeds.remove(&signal);
 }
@@ -555,9 +535,7 @@ fn process_signal(
             let downstreams = get_downstreams(world, signal);
             panic!(
                 "missing SystemRunner for signal {:?} during processing (entity exists). upstreams={:?}, downstreams={:?}",
-                signal,
-                upstreams,
-                downstreams
+                signal, upstreams, downstreams
             );
         }
     };
@@ -579,11 +557,7 @@ fn process_signal(
     }
 }
 
-pub(crate) fn process_signals(
-    world: &mut World,
-    signals: impl AsRef<[SignalSystem]>,
-    input: Box<dyn AnyClone>,
-) {
+pub(crate) fn process_signals(world: &mut World, signals: impl AsRef<[SignalSystem]>, input: Box<dyn AnyClone>) {
     let signals = signals.as_ref();
     if signals.is_empty() {
         return;
@@ -596,12 +570,7 @@ pub(crate) fn process_signals(
             let runner = world
                 .get::<SystemRunner>(*signal)
                 .cloned()
-                .unwrap_or_else(|| {
-                    panic!(
-                        "missing SystemRunner for signal {:?} during processing",
-                        signal
-                    )
-                });
+                .unwrap_or_else(|| panic!("missing SystemRunner for signal {:?} during processing", signal));
             if let Some(output) = runner.run(world, input) {
                 enqueue_inputs(world, &mut inputs, signal, output);
             }
@@ -664,7 +633,7 @@ pub(crate) fn process_signal_graph(world: &mut World) {
 /// called on a corresponding [`SignalHandle`] or a downstream [`SignalHandle`].
 /// Adding [`SignalHandle`]s to the [`SignalHandles`] [`Component`] will take care
 /// of this when the corresponding [`Entity`] is despawned, and using the
-/// [`JonmoBuilder`](super::builder::JonmoBuilder) will manage this internally.
+/// [`jonmo::Builder`](super::builder::Builder) will manage this internally.
 #[derive(Clone, Deref, Debug)]
 pub struct SignalHandle(pub SignalSystem);
 
@@ -688,15 +657,16 @@ impl SignalHandle {
 }
 
 fn cleanup_signal_handles(mut world: DeferredWorld, HookContext { entity, .. }: HookContext) {
-    if let Some(handles) = world.get_entity_mut(entity).ok().and_then(|mut entity| {
-        entity
-            .get_mut::<SignalHandles>()
-            .map(|mut handles| handles.0.drain(..).collect::<Vec<_>>())
-    }) {
-        let mut commands = world.commands();
-        for handle in handles {
-            commands.queue(|world: &mut World| handle.cleanup(world));
-        }
+    let handles: Vec<_> = world
+        .entity_mut(entity)
+        .get_mut::<SignalHandles>()
+        .unwrap()
+        .0
+        .drain(..)
+        .collect();
+    let mut commands = world.commands();
+    for handle in handles {
+        commands.queue(|world: &mut World| handle.cleanup(world));
     }
 }
 
@@ -767,11 +737,11 @@ impl LazySystem {
                 signal
             }
             LazySystem::Registered(signal) => {
-                if let Ok(mut system) = world.get_entity_mut(**signal)
-                    && let Some(mut registration_count) = system.get_mut::<SignalRegistrationCount>()
-                {
-                    registration_count.increment();
-                }
+                world
+                    .entity_mut(**signal)
+                    .get_mut::<SignalRegistrationCount>()
+                    .unwrap()
+                    .increment();
                 *signal
             }
         }
@@ -794,9 +764,8 @@ impl LazySignal {
 
     pub(crate) fn register(self, world: &mut World) -> SignalSystem {
         let signal = self.inner.system.write().unwrap().register(world);
-        if let Ok(mut entity) = world.get_entity_mut(*signal)
-            && !entity.contains::<LazySignalHolder>()
-        {
+        let mut entity = world.entity_mut(*signal);
+        if !entity.contains::<LazySignalHolder>() {
             entity.insert(LazySignalHolder(self));
         }
         signal
@@ -839,9 +808,10 @@ fn unlink_downstreams_and_mark(world: &mut World, signal: SignalSystem) {
                     downstream_entity.remove::<Upstream>();
                 }
             }
-            if let Some(mut state) = world.get_resource_mut::<SignalGraphState>() {
-                state.edge_change_seeds.insert(downstream);
-            }
+            world
+                .resource_mut::<SignalGraphState>()
+                .edge_change_seeds
+                .insert(downstream);
         }
     }
 }
@@ -856,9 +826,7 @@ pub(crate) fn despawn_stale_signals(world: &mut World) {
         if should_despawn {
             unlink_downstreams_and_mark(world, signal);
             remove_signal_from_graph_state(world, signal);
-            if let Ok(entity) = world.get_entity_mut(*signal) {
-                entity.despawn();
-            }
+            world.entity_mut(*signal).despawn();
         }
     }
 }
@@ -1028,12 +996,7 @@ fn poll_signal_one_shot(In(signal): In<SignalSystem>, world: &mut World) -> Opti
         let runner = world
             .get::<SystemRunner>(*node)
             .cloned()
-            .unwrap_or_else(|| {
-                panic!(
-                    "missing SystemRunner for signal {:?} during processing",
-                    node
-                )
-            });
+            .unwrap_or_else(|| panic!("missing SystemRunner for signal {:?} during processing", node));
         let upstreams: Vec<SignalSystem> = world
             .get::<Upstream>(*node)
             .map(|u| {
@@ -1082,7 +1045,7 @@ pub fn poll_signal(world: &mut World, signal: SignalSystem) -> Option<Box<dyn An
 /// use jonmo::{prelude::*, graph::*};
 ///
 /// let mut world = World::new();
-/// let signal = *SignalBuilder::from_system(|_: In<()>| 1).register(&mut world);
+/// let signal = *signal::from_system(|_: In<()>| 1).register(&mut world);
 /// poll_signal(&mut world, signal).and_then(downcast_any_clone::<usize>); // outputs an `Option<usize>`
 /// ```
 pub fn downcast_any_clone<T: 'static>(any_clone: Box<dyn AnyClone>) -> Option<T> {
diff --git a/src/lib.rs b/src/lib.rs
index 72621ab..4a0cc93 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,8 +14,6 @@ use bevy_ecs::{
     schedule::{InternedScheduleLabel, ScheduleLabel},
 };
 
-#[cfg(feature = "builder")]
-pub mod builder;
 pub mod graph;
 pub mod signal;
 pub mod signal_map;
@@ -23,6 +21,13 @@ pub mod signal_vec;
 #[allow(missing_docs)]
 pub mod utils;
 
+cfg_if::cfg_if! {
+    if #[cfg(feature = "builder")] {
+        pub mod builder;
+        pub use builder::Builder;
+    }
+}
+
 /// Includes the systems required for [jonmo](crate) to function.
 ///
 /// # Example
@@ -116,19 +121,15 @@ impl Plugin for JonmoPlugin {
 /// `use jonmo::prelude::*;` imports everything one needs to use start using [jonmo](crate).
 pub mod prelude {
     #[cfg(feature = "builder")]
-    pub use crate::builder::{JonmoBuilder, SignalMapTaskExt, SignalTask, SignalTaskExt, SignalVecTaskExt};
+    pub use crate::builder::{SignalMapTaskExt, SignalTask, SignalTaskExt, SignalVecTaskExt};
     pub use crate::{
         JonmoPlugin,
         graph::SignalHandles,
-        signal::{self, IntoSignalEither, Signal, SignalBuilder, SignalEither, SignalExt},
+        signal::{self, IntoSignalEither, Signal, SignalEither, SignalExt},
         signal_map::{
-            IntoSignalMapEither, MutableBTreeMap, MutableBTreeMapBuilder, MutableBTreeMapData, SignalMap,
-            SignalMapEither, SignalMapExt,
-        },
-        signal_vec::{
-            IntoSignalVecEither, MutableVec, MutableVecBuilder, MutableVecData, SignalVec, SignalVecEither,
-            SignalVecExt,
+            IntoSignalMapEither, MutableBTreeMap, MutableBTreeMapData, SignalMap, SignalMapEither, SignalMapExt,
         },
+        signal_vec::{IntoSignalVecEither, MutableVec, MutableVecData, SignalVec, SignalVecEither, SignalVecExt},
         utils::{LazyEntity, clone, deref_cloned, deref_copied},
     };
     #[doc(no_inline)]
diff --git a/src/signal.rs b/src/signal.rs
index 5c639d7..db27eec 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -73,8 +73,8 @@ impl<O: 'static> Signal for Box<dyn SignalDynClone<Item = O> + Send + Sync> {
     }
 }
 
-/// Signal graph node which takes an input of [`In<()>`] and has no upstreams. See [`SignalBuilder`]
-/// methods for examples.
+/// Signal graph node which takes an input of [`In<()>`] and has no upstreams. See
+/// [`from_system`] for examples.
 pub struct Source<O> {
     signal: LazySignal,
     _marker: PhantomData<fn() -> O>,
@@ -941,137 +941,170 @@ cfg_if::cfg_if! {
     }
 }
 
-/// Provides static methods for creating [`Source`] signals.
-pub struct SignalBuilder;
-
-impl From<Entity> for Source<Entity> {
-    fn from(entity: Entity) -> Self {
-        SignalBuilder::from_entity(entity)
+/// Creates a [`Source`] signal from a [`System`] that takes [`In<()>`].
+pub fn from_system<O, IOO, F, M>(system: F) -> Source<O>
+where
+    O: Clone + 'static,
+    IOO: Into<Option<O>> + 'static,
+    F: IntoSystem<In<()>, IOO, M> + SSs,
+{
+    Source {
+        signal: lazy_signal_from_system(system),
+        _marker: PhantomData,
     }
 }
 
-impl SignalBuilder {
-    /// Creates a [`Source`] signal from a [`System`] that takes [`In<()>`].
-    pub fn from_system<O, IOO, F, M>(system: F) -> Source<O>
-    where
-        O: Clone + 'static,
-        IOO: Into<Option<O>> + 'static,
-        F: IntoSystem<In<()>, IOO, M> + SSs,
-    {
-        Source {
-            signal: lazy_signal_from_system(system),
-            _marker: PhantomData,
+/// Creates a [`Source`] signal from an [`FnMut`].
+pub fn from_function<O, F>(mut f: F) -> Source<O>
+where
+    O: Clone + SSs,
+    F: FnMut() -> O + SSs,
+{
+    from_system(move |_: In<()>| Some(f()))
+}
+
+/// Creates a [`Source`] signal that always outputs a constant value.
+pub fn always<O>(value: O) -> Source<O>
+where
+    O: Clone + SSs,
+{
+    from_system(move |_: In<()>| Some(value.clone()))
+}
+
+/// Creates a [`Signal`] that outputs a value once and then terminates forever.
+pub fn once<O>(value: O) -> Source<O>
+where
+    O: Clone + SSs,
+{
+    from_system(move |_: In<()>, mut emitted: Local<bool>| {
+        if *emitted {
+            None
+        } else {
+            *emitted = true;
+            Some(value.clone())
         }
-    }
+    })
+}
 
-    /// Creates a [`Source`] signal from an [`FnMut`].
-    pub fn from_function<O, F>(mut f: F) -> Source<O>
-    where
-        O: Clone + SSs,
-        F: FnMut() -> O + SSs,
-    {
-        Self::from_system(move |_: In<()>| Some(f()))
-    }
+/// Creates a [`Source`] signal from an [`Entity`].
+pub fn from_entity(entity: Entity) -> Source<Entity> {
+    from_system(move |_: In<()>| entity)
+}
 
-    /// Creates a [`Source`] signal that always outputs a constant value.
-    pub fn always<O>(value: O) -> Source<O>
-    where
-        O: Clone + SSs,
-    {
-        Self::from_system(move |_: In<()>| Some(value.clone()))
-    }
+/// Creates a [`Source`] signal from a [`LazyEntity`].
+pub fn from_lazy_entity(entity: LazyEntity) -> Source<Entity> {
+    from_system(move |_: In<()>| *entity)
+}
 
-    /// Creates a [`Source`] signal from an [`Entity`].
-    pub fn from_entity(entity: Entity) -> Source<Entity> {
-        Self::from_system(move |_: In<()>| entity)
-    }
+/// Creates a [`Source`] signal from an [`Entity`]'s `generations`-th generation ancestor's
+/// [`Entity`], terminating for frames where it does not exist. Passing `0` to `generation` will
+/// output the [`Entity`] itself.
+pub fn from_ancestor(entity: Entity, generations: usize) -> Map<Source<Entity>, Entity> {
+    from_entity(entity).map(ancestor_map(generations))
+}
 
-    /// Creates a [`Source`] signal from a [`LazyEntity`].
-    pub fn from_lazy_entity(entity: LazyEntity) -> Source<Entity> {
-        Self::from_system(move |_: In<()>| *entity)
-    }
+/// Creates a [`Source`] signal from a [`LazyEntity`]'s `generations`-th generation ancestor's
+/// [`Entity`], terminating for frames where it does not exist. Passing `0` to `generation` will
+/// output the [`LazyEntity`]'s  [`Entity`] itself.
+pub fn from_ancestor_lazy(entity: LazyEntity, generations: usize) -> Map<Source<Entity>, Entity> {
+    from_lazy_entity(entity).map(ancestor_map(generations))
+}
 
-    /// Creates a [`Source`] signal from an [`Entity`]'s `generations`-th generation ancestor's
-    /// [`Entity`], terminating for frames where it does not exist. Passing `0` to `generation` will
-    /// output the [`Entity`] itself.
-    pub fn from_ancestor(entity: Entity, generations: usize) -> Map<Source<Entity>, Entity> {
-        Self::from_entity(entity).map(ancestor_map(generations))
-    }
+/// Creates a [`Source`] signal from an [`Entity`]'s parent's [`Entity`], terminating for frames
+/// where it does not exist. Passing `0` to `generation` will output the [`Entity`] itself.
+pub fn from_parent(entity: Entity) -> Map<Source<Entity>, Entity> {
+    from_ancestor(entity, 1)
+}
 
-    /// Creates a [`Source`] signal from a [`LazyEntity`]'s `generations`-th generation ancestor's
-    /// [`Entity`], terminating for frames where it does not exist. Passing `0` to `generation` will
-    /// output the [`LazyEntity`]'s  [`Entity`] itself.
-    pub fn from_ancestor_lazy(entity: LazyEntity, generations: usize) -> Map<Source<Entity>, Entity> {
-        Self::from_lazy_entity(entity).map(ancestor_map(generations))
-    }
+/// Creates a [`Source`] signal from a [`LazyEntity`]'s parent's [`Entity`], terminating for
+/// frames where it does not exist. Passing `0` to `generation` will output the
+/// [`LazyEntity`]'s [`Entity`] itself.
+pub fn from_parent_lazy(entity: LazyEntity) -> Map<Source<Entity>, Entity> {
+    from_ancestor_lazy(entity, 1)
+}
 
-    /// Creates a [`Source`] signal from an [`Entity`]'s parent's [`Entity`], terminating for frames
-    /// where it does not exist. Passing `0` to `generation` will output the [`Entity`] itself.
-    pub fn from_parent(entity: Entity) -> Map<Source<Entity>, Entity> {
-        Self::from_ancestor(entity, 1)
-    }
+/// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], terminating for the
+/// frame if the [`Entity`] does not exist or the [`Component`] does not exist on the
+/// [`Entity`].
+pub fn from_component<C>(entity: Entity) -> Source<C>
+where
+    C: Component + Clone,
+{
+    from_system(move |_: In<()>, components: Query<&C>| components.get(entity).ok().cloned())
+}
 
-    /// Creates a [`Source`] signal from a [`LazyEntity`]'s parent's [`Entity`], terminating for
-    /// frames where it does not exist. Passing `0` to `generation` will output the
-    /// [`LazyEntity`]'s [`Entity`] itself.
-    pub fn from_parent_lazy(entity: LazyEntity) -> Map<Source<Entity>, Entity> {
-        Self::from_ancestor_lazy(entity, 1)
-    }
+/// Creates a [`Source`] signal from a [`LazyEntity`] and a [`Component`], terminating for the
+/// frame if the [`Entity`] does not exist or the [`Component`] does not exist on the
+/// corresponding [`Entity`].
+pub fn from_component_lazy<C>(entity: LazyEntity) -> Source<C>
+where
+    C: Component + Clone,
+{
+    from_system(move |_: In<()>, components: Query<&C>| components.get(*entity).ok().cloned())
+}
 
-    /// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], terminating for the
-    /// frame if the [`Entity`] does not exist or the [`Component`] does not exist on the
-    /// [`Entity`].
-    pub fn from_component<C>(entity: Entity) -> Source<C>
-    where
-        C: Component + Clone,
-    {
-        Self::from_system(move |_: In<()>, components: Query<&C>| components.get(entity).ok().cloned())
-    }
+/// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], always outputting an
+/// [`Option`].
+pub fn from_component_option<C>(entity: Entity) -> Source<Option<C>>
+where
+    C: Component + Clone,
+{
+    from_system(move |_: In<()>, components: Query<&C>| Some(components.get(entity).ok().cloned()))
+}
 
-    /// Creates a [`Source`] signal from a [`LazyEntity`] and a [`Component`], terminating for the
-    /// frame if the [`Entity`] does not exist or the [`Component`] does not exist on the
-    /// corresponding [`Entity`].
-    pub fn from_component_lazy<C>(entity: LazyEntity) -> Source<C>
-    where
-        C: Component + Clone,
-    {
-        Self::from_system(move |_: In<()>, components: Query<&C>| components.get(*entity).ok().cloned())
-    }
+/// Creates a [`Source`] signal from a [`LazyEntity`] and a [`Component`], always outputting an
+/// [`Option`].
+pub fn from_component_option_lazy<C>(entity: LazyEntity) -> Source<Option<C>>
+where
+    C: Component + Clone,
+{
+    from_system(move |_: In<()>, components: Query<&C>| Some(components.get(*entity).ok().cloned()))
+}
 
-    /// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], always outputting an
-    /// [`Option`].
-    pub fn from_component_option<C>(entity: Entity) -> Source<Option<C>>
-    where
-        C: Component + Clone,
-    {
-        Self::from_system(move |_: In<()>, components: Query<&C>| Some(components.get(entity).ok().cloned()))
-    }
+/// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], only outputting on
+/// frames where the [`Component`] has [`Changed`]. Terminates for the frame if the [`Entity`]
+/// does not exist, the [`Component`] does not exist, or the [`Component`] has not changed.
+pub fn from_component_changed<C>(entity: Entity) -> Source<C>
+where
+    C: Component + Clone,
+{
+    from_system(move |_: In<()>, components: Query<&C, Changed<C>>| components.get(entity).ok().cloned())
+}
 
-    /// Creates a [`Source`] signal from a [`LazyEntity`] and a [`Component`], always outputting an
-    /// [`Option`].
-    pub fn from_component_option_lazy<C>(entity: LazyEntity) -> Source<Option<C>>
-    where
-        C: Component + Clone,
-    {
-        Self::from_system(move |_: In<()>, components: Query<&C>| Some(components.get(*entity).ok().cloned()))
-    }
+/// Creates a [`Source`] signal from a [`LazyEntity`] and a [`Component`], only outputting on
+/// frames where the [`Component`] has [`Changed`]. Terminates for the frame if the [`Entity`]
+/// does not exist, the [`Component`] does not exist, or the [`Component`] has not changed.
+pub fn from_component_changed_lazy<C>(entity: LazyEntity) -> Source<C>
+where
+    C: Component + Clone,
+{
+    from_system(move |_: In<()>, components: Query<&C, Changed<C>>| components.get(*entity).ok().cloned())
+}
 
-    /// Creates a signal from a [`Resource`], terminating for the frame if the [`Resource`] does not
-    /// exist.
-    pub fn from_resource<R>() -> Source<R>
-    where
-        R: Resource + Clone,
-    {
-        Self::from_system(move |_: In<()>, resource: Option<Res<R>>| resource.as_deref().cloned())
-    }
+/// Creates a signal from a [`Resource`], terminating for the frame if the [`Resource`] does not
+/// exist.
+pub fn from_resource<R>() -> Source<R>
+where
+    R: Resource + Clone,
+{
+    from_system(move |_: In<()>, resource: Option<Res<R>>| resource.as_deref().cloned())
+}
 
-    /// Creates a signal from a [`Resource`], always outputting an [`Option`].
-    pub fn from_resource_option<R>() -> Source<Option<R>>
-    where
-        R: Resource + Clone,
-    {
-        Self::from_system(move |_: In<()>, resource: Option<Res<R>>| Some(resource.as_deref().cloned()))
-    }
+/// Creates a signal from a [`Resource`], always outputting an [`Option`].
+pub fn from_resource_option<R>() -> Source<Option<R>>
+where
+    R: Resource + Clone,
+{
+    from_system(move |_: In<()>, resource: Option<Res<R>>| Some(resource.as_deref().cloned()))
+}
+
+/// Creates a signal from a [`Resource`], only outputting on frames where the [`Resource`] has
+/// [`Changed`]. Terminates for the frame if the [`Resource`] does not exist or has not changed.
+pub fn from_resource_changed<R>() -> Source<R>
+where
+    R: Resource + Clone,
+{
+    from_system(move |_: In<()>, resource: Option<Res<R>>| resource.filter(|r| r.is_changed()).map(|r| r.clone()))
 }
 
 /// Converts an `Option<Signal<A>>` into a `Signal<Option<A>>`.
@@ -1079,7 +1112,7 @@ impl SignalBuilder {
 /// This is mostly useful with [`.switch`](SignalExt::switch) or [`.flatten`](SignalExt::flatten).
 ///
 /// If the value is `None` then it emits `None` once and then terminates (implemented as
-/// `SignalBuilder::always(None).first()`).
+/// `signal::once(None)`).
 ///
 /// If the value is `Some(signal)` then it will return the result of the signal,
 /// except wrapped in `Some`.
@@ -1097,10 +1130,10 @@ impl SignalBuilder {
 /// world.insert_resource(Enabled(false));
 ///
 /// // Turn `Signal<Item = Option<Signal<Item = T>>>` into `Signal<Item = Option<T>>`.
-/// let maybe_value = SignalBuilder::from_resource::<Enabled>()
+/// let maybe_value = signal::from_resource::<Enabled>()
 ///     .dedupe()
 ///     .map_in(|enabled: Enabled| enabled.0)
-///     .map_true_in(|| SignalBuilder::from_system(|_: In<()>| 42))
+///     .map_true_in(|| signal::from_system(|_: In<()>| 42))
 ///     .map_in(signal::option)
 ///     .flatten();
 /// ```
@@ -1111,7 +1144,7 @@ where
 {
     match value {
         Some(signal) => signal.map_in(Some).left_either(),
-        None => SignalBuilder::always(None).first().right_either(),
+        None => once(None).right_either(),
     }
 }
 
@@ -1181,14 +1214,14 @@ where
     /// let mut world = World::new();
     /// world.insert_resource(UseSquare(true));
     ///
-    /// let signal = SignalBuilder::from_system(|_: In<()>, res: Res<UseSquare>| res.0)
+    /// let signal = signal::from_system(|_: In<()>, res: Res<UseSquare>| res.0)
     ///     .map(move |In(use_square): In<bool>| {
     ///         if use_square {
-    ///             SignalBuilder::from_system(|_: In<()>| 10)
+    ///             signal::from_system(|_: In<()>| 10)
     ///                 .map(|In(x): In<i32>| x * x)
     ///                 .left_either()
     ///         } else {
-    ///             SignalBuilder::from_system(|_: In<()>| 42).right_either()
+    ///             signal::from_system(|_: In<()>| 42).right_either()
     ///         }
     ///     })
     ///     .flatten();
@@ -1220,12 +1253,12 @@ where
     /// let mut world = World::new();
     /// world.insert_resource(Mode(false));
     ///
-    /// let signal = SignalBuilder::from_system(|_: In<()>, res: Res<Mode>| res.0)
+    /// let signal = signal::from_system(|_: In<()>, res: Res<Mode>| res.0)
     ///     .map(move |In(mode): In<bool>| {
     ///         if mode {
-    ///             SignalBuilder::from_system(|_: In<()>| "A").left_either()
+    ///             signal::from_system(|_: In<()>| "A").left_either()
     ///         } else {
-    ///             SignalBuilder::from_system(|_: In<()>| "B")
+    ///             signal::from_system(|_: In<()>| "B")
     ///                 .filter(|In(x): In<&str>| x.len() > 0)
     ///                 .right_either()
     ///         }
@@ -1255,7 +1288,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system(|_: In<()>| 1).map(|In(x): In<i32>| x * 2); // outputs `2`
+    /// signal::from_system(|_: In<()>| 1).map(|In(x): In<i32>| x * 2); // outputs `2`
     /// ```
     fn map<O, IOO, F, M>(self, system: F) -> Map<Self, O>
     where
@@ -1284,7 +1317,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system(|_: In<()>| 1).map_in(|x: i32| x * 2); // outputs `2`
+    /// signal::from_system(|_: In<()>| 1).map_in(|x: i32| x * 2); // outputs `2`
     /// ```
     fn map_in<O, IOO, F>(self, mut function: F) -> Map<Self, O>
     where
@@ -1310,7 +1343,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system(|_: In<()>| 1).map_in_ref(ToString::to_string); // outputs `"1"`
+    /// signal::from_system(|_: In<()>| 1).map_in_ref(ToString::to_string); // outputs `"1"`
     /// ```
     fn map_in_ref<O, IOO, F>(self, mut function: F) -> Map<Self, O>
     where
@@ -1337,10 +1370,10 @@ pub trait SignalExt: Signal {
     ///
     /// let mut world = World::new();
     /// let entity = world.spawn(Value(0)).id();
-    /// SignalBuilder::from_entity(entity).component::<Value>(); // outputs `Value(0)`
+    /// signal::from_entity(entity).component::<Value>(); // outputs `Value(0)`
     ///
     /// let entity = world.spawn_empty().id();
-    /// SignalBuilder::from_entity(entity).component::<Value>(); // terminates
+    /// signal::from_entity(entity).component::<Value>(); // terminates
     /// ```
     fn component<C>(self) -> MapComponent<Self, C>
     where
@@ -1367,10 +1400,10 @@ pub trait SignalExt: Signal {
     ///
     /// let mut world = World::new();
     /// let entity = world.spawn(Value(0)).id();
-    /// SignalBuilder::from_entity(entity).component_option::<Value>(); // outputs `Some(Value(0))`
+    /// signal::from_entity(entity).component_option::<Value>(); // outputs `Some(Value(0))`
     ///
     /// let entity = world.spawn_empty().id();
-    /// SignalBuilder::from_entity(entity).component::<Value>(); // outputs `None`
+    /// signal::from_entity(entity).component::<Value>(); // outputs `None`
     /// ```
     fn component_option<C>(self) -> ComponentOption<Self, C>
     where
@@ -1398,10 +1431,10 @@ pub trait SignalExt: Signal {
     ///
     /// let mut world = World::new();
     /// let entity = world.spawn(Value(0)).id();
-    /// SignalBuilder::from_entity(entity).component_changed::<Value>(); // outputs `Value(0)` on changed frames
+    /// signal::from_entity(entity).component_changed::<Value>(); // outputs `Value(0)` on changed frames
     ///
     /// let entity = world.spawn_empty().id();
-    /// SignalBuilder::from_entity(entity).component_changed::<Value>(); // terminates
+    /// signal::from_entity(entity).component_changed::<Value>(); // terminates
     /// ```
     fn component_changed<C>(self) -> ComponentChanged<Self, C>
     where
@@ -1429,10 +1462,10 @@ pub trait SignalExt: Signal {
     ///
     /// let mut world = World::new();
     /// let entity = world.spawn(Value(0)).id();
-    /// SignalBuilder::from_entity(entity).has_component::<Value>(); // outputs `true`
+    /// signal::from_entity(entity).has_component::<Value>(); // outputs `true`
     ///
     /// let entity = world.spawn_empty().id();
-    /// SignalBuilder::from_entity(entity).has_component::<Value>(); // outputs `false`
+    /// signal::from_entity(entity).has_component::<Value>(); // outputs `false`
     /// ```
     fn has_component<C>(self) -> HasComponent<Self, C>
     where
@@ -1454,7 +1487,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
     ///         *state += 1;
     ///         *state / 2
@@ -1498,7 +1531,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
     ///         *state += 1;
     ///         *state
@@ -1531,7 +1564,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
     ///         *state += 1;
     ///         *state / 2
@@ -1555,7 +1588,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// let signal = SignalBuilder::from_system(|_: In<()>| 0);
+    /// let signal = signal::from_system(|_: In<()>| 0);
     /// signal.clone().eq(0); // outputs `true`
     /// signal.eq(1); // outputs `false`
     /// ```
@@ -1577,7 +1610,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// let signal = SignalBuilder::from_system(|_: In<()>| 0);
+    /// let signal = signal::from_system(|_: In<()>| 0);
     /// signal.clone().neq(0); // outputs `false`
     /// signal.neq(1); // outputs `true`
     /// ```
@@ -1599,7 +1632,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system(|_: In<()>| true).not(); // outputs `false`
+    /// signal::from_system(|_: In<()>| true).not(); // outputs `false`
     /// ```
     fn not(self) -> Not<Self>
     where
@@ -1620,7 +1653,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
     ///         *state += 1;
     ///         *state % 2
@@ -1655,9 +1688,9 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// Combines this [`Signal`] with another [`Signal`], outputting a tuple with both of their latest
-    /// outputs. The resulting [`Signal`] will only output a value when both input [`Signal`]s have
-    /// outputted a value.
+    /// Combines this [`Signal`] with another [`Signal`], outputting a tuple with both of their
+    /// latest outputs. The resulting [`Signal`] will only output a value when both input
+    /// [`Signal`]s have outputted a value.
     ///
     /// # Example
     ///
@@ -1665,8 +1698,8 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// let signal_1 = SignalBuilder::from_system(|_: In<()>| 1);
-    /// let signal_2 = SignalBuilder::from_system(|_: In<()>| 2);
+    /// let signal_1 = signal::from_system(|_: In<()>| 1);
+    /// let signal_2 = signal::from_system(|_: In<()>| 2);
     /// signal_1.with(signal_2); // outputs `(1, 2)`
     /// ```
     fn with<Other>(self, other: Other) -> With<Self, Other>
@@ -1679,22 +1712,20 @@ pub trait SignalExt: Signal {
         let signal = LazySignal::new(move |world: &mut World| {
             let with_entity = LazyEntity::new();
 
-            let left_wrapper = self.map(clone!((with_entity) move |In(left): In<Self::Item>, world: &mut World| {
-                if let Some(mut cache) = world.get_mut::<WithCache<Self::Item, Other::Item>>(with_entity.get()) {
-                    cache.left = Some(left);
-                }
-            }));
-            let right_wrapper = other.map(clone!((with_entity) move |In(right): In<Other::Item>, world: &mut World| {
-                if let Some(mut cache) = world.get_mut::<WithCache<Self::Item, Other::Item>>(with_entity.get()) {
-                    cache.right = Some(right);
-                }
-            }));
+            let left_wrapper = self.map(
+                clone!((with_entity) move |In(left): In<Self::Item>, world: &mut World| {
+                    world.get_mut::<WithCache<Self::Item, Other::Item>>(*with_entity).unwrap().left = Some(left);
+                }),
+            );
+            let right_wrapper = other.map(
+                clone!((with_entity) move |In(right): In<Other::Item>, world: &mut World| {
+                    world.get_mut::<WithCache<Self::Item, Other::Item>>(*with_entity).unwrap().right = Some(right);
+                }),
+            );
 
             let with_signal = lazy_signal_from_system::<_, (Self::Item, Other::Item), _, _, _>(
                 clone!((with_entity) move |_: In<()>, world: &mut World| {
-                    let Some(cache) = world.get_mut::<WithCache<Self::Item, Other::Item>>(with_entity.get()) else {
-                        return None;
-                    };
+                    let cache = world.get_mut::<WithCache<Self::Item, Other::Item>>(*with_entity).unwrap();
                     match (&cache.left, &cache.right) {
                         (Some(left), Some(right)) => Some((left.clone(), right.clone())),
                         _ => None,
@@ -1703,9 +1734,9 @@ pub trait SignalExt: Signal {
             );
 
             let signal = with_signal.register(world);
-            if let Ok(mut entity) = world.get_entity_mut(*signal) {
-                entity.insert(WithCache::<Self::Item, Other::Item>::default());
-            }
+            world
+                .entity_mut(*signal)
+                .insert(WithCache::<Self::Item, Other::Item>::default());
             with_entity.set(*signal);
 
             let SignalHandle(left_upstream) = left_wrapper.register(world);
@@ -1735,13 +1766,13 @@ pub trait SignalExt: Signal {
     ///
     /// let mut world = World::new();
     /// world.insert_resource(Toggle(false));
-    /// let signal = SignalBuilder::from_resource::<Toggle>()
+    /// let signal = signal::from_resource::<Toggle>()
     ///     .dedupe()
     ///     .map(move |In(toggle): In<Toggle>| {
     ///         if toggle.0 {
-    ///             SignalBuilder::from_system(|_: In<()>| 1)
+    ///             signal::from_system(|_: In<()>| 1)
     ///         } else {
-    ///             SignalBuilder::from_system(|_: In<()>| 2)
+    ///             signal::from_system(|_: In<()>| 2)
     ///         }
     ///     })
     ///     .flatten();
@@ -1762,19 +1793,15 @@ pub trait SignalExt: Signal {
         }
 
         let signal = LazySignal::new(move |world: &mut World| {
-            // 1. State entity that holds the latest value, serving as the communication channel
-            //    between dynamic inner signals and the static output signal.
+            // 1. State entity that holds the latest value, serving as the communication channel between dynamic
+            //    inner signals and the static output signal.
             let reader_entity = LazyEntity::new();
 
-            // 2. The output signal (reader). Reads from state and propagates. Has no upstream
-            //    dependencies; triggered manually by the forwarder.
-            let reader_system = *SignalBuilder::from_system::<<Self::Item as Signal>::Item, _, _, _>(
+            // 2. The output signal (reader). Reads from state and propagates. Has no upstream dependencies;
+            //    triggered manually by the forwarder.
+            let reader_system = *from_system::<<Self::Item as Signal>::Item, _, _, _>(
                     clone!((reader_entity) move |_: In<()>, mut query: Query<&mut FlattenState<<Self::Item as Signal>::Item>, Allow<Internal>>| {
-                        if let Ok(mut state) = query.get_mut(reader_entity.get()) {
-                            state.value.take()
-                        } else {
-                            None
-                        }
+                        query.get_mut(*reader_entity).unwrap().value.take()
                     }),
                 )
                 .register(world);
@@ -1809,21 +1836,20 @@ pub trait SignalExt: Signal {
                             .and_then(downcast_any_clone::<<Self::Item as Signal>::Item>);
 
                         // e. Write initial value to state.
-                        if let Some(value) = initial_value
-                            && let Some(mut state) =
-                                world.get_mut::<FlattenState<<Self::Item as Signal>::Item>>(*reader_system)
-                        {
-                            state.value = Some(value);
+                        if let Some(value) = initial_value {
+                            world
+                                .get_mut::<FlattenState<<Self::Item as Signal>::Item>>(*reader_system)
+                                .unwrap()
+                                .value = Some(value);
                         }
 
                         // f. Set up forwarder for subsequent values.
                         let forwarder_handle = inner_signal
                             .map(move |In(value), world: &mut World| {
-                                if let Some(mut state) =
-                                    world.get_mut::<FlattenState<<Self::Item as Signal>::Item>>(*reader_system)
-                                {
-                                    state.value = Some(value);
-                                }
+                                world
+                                    .get_mut::<FlattenState<<Self::Item as Signal>::Item>>(*reader_system)
+                                    .unwrap()
+                                    .value = Some(value);
                                 process_signals(world, [reader_system], Box::new(()));
                             })
                             .register(world);
@@ -1864,13 +1890,13 @@ pub trait SignalExt: Signal {
     /// let mut world = World::new();
     /// world.insert_resource(Toggle(false));
     /// let signal =
-    ///     SignalBuilder::from_resource::<Toggle>()
+    ///     signal::from_resource::<Toggle>()
     ///         .dedupe()
     ///         .switch(move |In(toggle): In<Toggle>| {
     ///             if toggle.0 {
-    ///                 SignalBuilder::from_system(|_: In<()>| 1)
+    ///                 signal::from_system(|_: In<()>| 1)
     ///             } else {
-    ///                 SignalBuilder::from_system(|_: In<()>| 2)
+    ///                 signal::from_system(|_: In<()>| 2)
     ///             }
     ///         });
     /// // `signal` outputs `2`
@@ -1905,13 +1931,19 @@ pub trait SignalExt: Signal {
     /// let mut world = World::new();
     /// world.insert_resource(Toggle(false));
     ///
-    /// let signal = SignalBuilder::from_resource::<Toggle>()
+    /// let signal = signal::from_resource::<Toggle>()
     ///     .dedupe()
     ///     .switch_signal_vec(move |In(toggle): In<Toggle>, world: &mut World| {
     ///         if toggle.0 {
-    ///             MutableVecBuilder::from([1, 2, 3]).spawn(world).signal_vec()
+    ///             MutableVec::builder()
+    ///                 .values([1, 2, 3])
+    ///                 .spawn(world)
+    ///                 .signal_vec()
     ///         } else {
-    ///             MutableVecBuilder::from([10, 20]).spawn(world).signal_vec()
+    ///             MutableVec::builder()
+    ///                 .values([10, 20])
+    ///                 .spawn(world)
+    ///                 .signal_vec()
     ///         }
     ///     });
     /// // `signal` outputs `SignalVec -> [10, 20]`
@@ -1932,16 +1964,13 @@ pub trait SignalExt: Signal {
 
             // The output system is a "poller". It runs when poked and drains its own queue.
             let output_signal_entity = LazyEntity::new();
-            let output_signal = *SignalBuilder::from_system::<Vec<VecDiff<S::Item>>, _, _, _>(
+            let output_signal = *from_system::<Vec<VecDiff<S::Item>>, _, _, _>(
                 clone!((output_signal_entity) move |_: In<()>, mut q: Query<&mut SwitcherQueue<S::Item>, Allow<Internal>>| {
-                    if let Ok(mut queue) = q.get_mut(*output_signal_entity) {
-                        if queue.0.is_empty() {
-                            None
-                        } else {
-                            Some(core::mem::take(&mut queue.0))
-                        }
-                    } else {
+                    let mut queue = q.get_mut(*output_signal_entity).unwrap();
+                    if queue.0.is_empty() {
                         None
+                    } else {
+                        Some(core::mem::take(&mut queue.0))
                     }
                 }),
             )
@@ -1980,10 +2009,12 @@ pub trait SignalExt: Signal {
                     // D. FORWARDING: The forwarder's only job is to queue ALL diffs from the inner
                     // signal and poke the output signal.
                     let forwarder_logic = move |In(diffs): In<Vec<VecDiff<S::Item>>>, world: &mut World| {
-                        if !diffs.is_empty()
-                            && let Some(mut queue) = world.get_mut::<SwitcherQueue<S::Item>>(*output_signal)
-                        {
-                            queue.0.extend(diffs);
+                        if !diffs.is_empty() {
+                            world
+                                .get_mut::<SwitcherQueue<S::Item>>(*output_signal)
+                                .unwrap()
+                                .0
+                                .extend(diffs);
                             process_signals(world, [output_signal], Box::new(()));
                         }
                     };
@@ -2037,15 +2068,17 @@ pub trait SignalExt: Signal {
     /// let mut world = World::new();
     /// world.insert_resource(Toggle(false));
     ///
-    /// let signal = SignalBuilder::from_resource::<Toggle>()
+    /// let signal = signal::from_resource::<Toggle>()
     ///     .dedupe()
     ///     .switch_signal_map(move |In(toggle): In<Toggle>, world: &mut World| {
     ///         if toggle.0 {
-    ///             MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///             MutableBTreeMap::builder()
+    ///                 .values([(1, 2), (3, 4)])
     ///                 .spawn(world)
     ///                 .signal_map()
     ///         } else {
-    ///             MutableBTreeMapBuilder::from([(10, 20)])
+    ///             MutableBTreeMap::builder()
+    ///                 .values([(10, 20)])
     ///                 .spawn(world)
     ///                 .signal_map()
     ///         }
@@ -2069,16 +2102,13 @@ pub trait SignalExt: Signal {
 
             // The output signal is a "poller". It runs when poked and drains its own queue.
             let output_signal_entity = LazyEntity::new();
-            let output_signal = *SignalBuilder::from_system::<Vec<super::signal_map::MapDiff<S::Key, S::Value>>, _, _, _>(
+            let output_signal = *from_system::<Vec<super::signal_map::MapDiff<S::Key, S::Value>>, _, _, _>(
                 clone!((output_signal_entity) move |_: In<()>, mut q: Query<&mut SwitcherQueue<S::Key, S::Value>, Allow<Internal>>| {
-                    if let Ok(mut queue) = q.get_mut(*output_signal_entity) {
-                        if queue.0.is_empty() {
-                            None
-                        } else {
-                            Some(core::mem::take(&mut queue.0))
-                        }
-                    } else {
+                    let mut queue = q.get_mut(*output_signal_entity).unwrap();
+                    if queue.0.is_empty() {
                         None
+                    } else {
+                        Some(core::mem::take(&mut queue.0))
                     }
                 }),
             )
@@ -2118,10 +2148,12 @@ pub trait SignalExt: Signal {
                     // signal and poke the output signal.
                     let forwarder_logic = move |In(diffs): In<Vec<super::signal_map::MapDiff<S::Key, S::Value>>>,
                                                 world: &mut World| {
-                        if !diffs.is_empty()
-                            && let Some(mut queue) = world.get_mut::<SwitcherQueue<S::Key, S::Value>>(*output_signal)
-                        {
-                            queue.0.extend(diffs);
+                        if !diffs.is_empty() {
+                            world
+                                .get_mut::<SwitcherQueue<S::Key, S::Value>>(*output_signal)
+                                .unwrap()
+                                .0
+                                .extend(diffs);
                             process_signals(world, [output_signal], Box::new(()));
                         }
                     };
@@ -2170,7 +2202,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
     ///        *state += 1;
     ///        *state
@@ -2213,7 +2245,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
     ///         *state = !*state;
     ///         *state
@@ -2263,7 +2295,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
     ///         *state = !*state;
     ///         *state
@@ -2296,8 +2328,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`true`], output the [`System`] result wrapped in [`Some`], otherwise
-    /// output [`None`].
+    /// If this [`Signal`] outputs [`true`], output the [`System`] result wrapped in [`Some`],
+    /// otherwise output [`None`].
     ///
     /// # Example
     ///
@@ -2305,7 +2337,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
     ///         *state = !*state;
     ///         *state
@@ -2342,8 +2374,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`true`], output the [`FnMut`] result wrapped in [`Some`], otherwise
-    /// output [`None`].
+    /// If this [`Signal`] outputs [`true`], output the [`FnMut`] result wrapped in [`Some`],
+    /// otherwise output [`None`].
     ///
     /// # Example
     ///
@@ -2351,7 +2383,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
     ///         *state = !*state;
     ///         *state
@@ -2382,8 +2414,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`false`], output the [`System`] result wrapped in [`Some`], otherwise
-    /// output [`None`].
+    /// If this [`Signal`] outputs [`false`], output the [`System`] result wrapped in [`Some`],
+    /// otherwise output [`None`].
     ///
     /// # Example
     ///
@@ -2391,7 +2423,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
     ///         *state = !*state;
     ///         *state
@@ -2428,8 +2460,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`false`], output the [`FnMut`] result wrapped in [`Some`], otherwise
-    /// output [`None`].
+    /// If this [`Signal`] outputs [`false`], output the [`FnMut`] result wrapped in [`Some`],
+    /// otherwise output [`None`].
     ///
     /// # Example
     ///
@@ -2437,7 +2469,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
     ///         *state = !*state;
     ///         *state
@@ -2476,7 +2508,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<Option<bool>>| {
     ///        *state = if state.is_some() { None } else { Some(true) };
     ///        *state
@@ -2528,7 +2560,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<Option<bool>>| {
     ///         *state = if state.is_some() { None } else { Some(true) };
     ///         *state
@@ -2570,7 +2602,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<Option<bool>>| {
     ///        *state = if state.is_some() { None } else { Some(true) };
     ///        *state
@@ -2616,10 +2648,10 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<Option<bool>>| {
-    ///        *state = if state.is_some() { None } else { Some(true) };
-    ///        *state
+    ///         *state = if state.is_some() { None } else { Some(true) };
+    ///         *state
     ///     }
     /// })
     /// .map_some_in(|state: bool| state); // outputs `Some(true)`, `None`, `Some(true)`, `None`, ...
@@ -2647,8 +2679,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`None`], output the [`System`] result wrapped in [`Some`], otherwise
-    /// output [`None`].
+    /// If this [`Signal`] outputs [`None`], output the [`System`] result wrapped in [`Some`],
+    /// otherwise output [`None`].
     ///
     /// # Example
     ///
@@ -2656,7 +2688,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<Option<bool>>| {
     ///         *state = if state.is_some() { None } else { Some(true) };
     ///         *state
@@ -2691,8 +2723,8 @@ pub trait SignalExt: Signal {
         }
     }
 
-    /// If this [`Signal`] outputs [`None`], output the [`FnMut`] result wrapped in [`Some`], otherwise
-    /// output [`None`].
+    /// If this [`Signal`] outputs [`None`], output the [`FnMut`] result wrapped in [`Some`],
+    /// otherwise output [`None`].
     ///
     /// # Example
     ///
@@ -2700,7 +2732,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<Option<bool>>| {
     ///         *state = if state.is_some() { None } else { Some(true) };
     ///         *state
@@ -2738,7 +2770,7 @@ pub trait SignalExt: Signal {
     ///
     /// Useful in situations where some [`System`] produces a static list every so often but one
     /// would like to render it dynamically e.g. with
-    /// [`JonmoBuilder::children_signal_vec`](super::builder::JonmoBuilder::children_signal_vec).
+    /// [`Builder::children_signal_vec`](crate::Builder::children_signal_vec).
     ///
     /// # Example
     ///
@@ -2746,7 +2778,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system({
+    /// signal::from_system({
     ///     move |_: In<()>, mut state: Local<Vec<usize>>| {
     ///         let new = state
     ///             .get(state.len().saturating_sub(1))
@@ -2787,7 +2819,7 @@ pub trait SignalExt: Signal {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system(|_: In<()>| 1)
+    /// signal::from_system(|_: In<()>| 1)
     ///     .debug() // logs `1`
     ///     .map_in(|x: i32| x * 2)
     ///     .debug(); // logs `2`
@@ -2817,9 +2849,11 @@ pub trait SignalExt: Signal {
     ///
     /// let condition = true;
     /// let signal = if condition {
-    ///     SignalBuilder::from_system(|_: In<()>| 1).map_in(|x: i32| x * 2).boxed() // this is a `Map<Source<i32>>`
+    ///     signal::from_system(|_: In<()>| 1)
+    ///         .map_in(|x: i32| x * 2)
+    ///         .boxed() // this is a `Map<Source<i32>>`
     /// } else {
-    ///     SignalBuilder::from_system(|_: In<()>| 1).dedupe().boxed() // this is a `Dedupe<Source<i32>>`
+    ///     signal::from_system(|_: In<()>| 1).dedupe().boxed() // this is a `Dedupe<Source<i32>>`
     /// }; // without the `.boxed()`, the compiler would not allow this
     /// ```
     fn boxed(self) -> Box<dyn Signal<Item = Self::Item>>
@@ -2840,13 +2874,11 @@ pub trait SignalExt: Signal {
     ///
     /// let condition = true;
     /// if condition {
-    ///     SignalBuilder::from_system(|_: In<()>| 1)
+    ///     signal::from_system(|_: In<()>| 1)
     ///         .map_in(|x: i32| x * 2)
     ///         .boxed_clone() // this is a `Map<Source<i32>>`
     /// } else {
-    ///     SignalBuilder::from_system(|_: In<()>| 1)
-    ///         .dedupe()
-    ///         .boxed_clone() // this is a `Dedupe<Source<i32>>`
+    ///     signal::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 SignalDynClone<Item = Self::Item>>
@@ -2879,9 +2911,9 @@ impl<T: ?Sized> SignalExt for T where T: Signal {}
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| 1);
-/// let s3 = SignalBuilder::from_system(|_: In<()>| 1);
+/// let s1 = signal::from_system(|_: In<()>| 1);
+/// let s2 = signal::from_system(|_: In<()>| 1);
+/// let s3 = signal::from_system(|_: In<()>| 1);
 ///
 /// let eq_signal = signal::eq!(s1, s2, s3); // outputs `true`
 /// ```
@@ -2946,8 +2978,8 @@ macro_rules! __signal_with_and_map {
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| true);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| true);
+/// let s1 = signal::from_system(|_: In<()>| true);
+/// let s2 = signal::from_system(|_: In<()>| true);
 ///
 /// let all_signal = signal::all!(s1, s2); // outputs `true`
 /// ```
@@ -2968,8 +3000,8 @@ macro_rules! all {
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| true);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| false);
+/// let s1 = signal::from_system(|_: In<()>| true);
+/// let s2 = signal::from_system(|_: In<()>| false);
 ///
 /// let any_signal = signal::any!(s1, s2); // outputs `true`
 /// ```
@@ -2991,9 +3023,9 @@ macro_rules! any {
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-/// let s3 = SignalBuilder::from_system(|_: In<()>| 3);
+/// let s1 = signal::from_system(|_: In<()>| 1);
+/// let s2 = signal::from_system(|_: In<()>| 2);
+/// let s3 = signal::from_system(|_: In<()>| 3);
 ///
 /// let distinct_signal = signal::distinct!(s1, s2, s3); // outputs `true`
 /// ```
@@ -3050,9 +3082,9 @@ macro_rules! __signal_pairwise_all {
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-/// let s3 = SignalBuilder::from_system(|_: In<()>| 3);
+/// let s1 = signal::from_system(|_: In<()>| 1);
+/// let s2 = signal::from_system(|_: In<()>| 2);
+/// let s3 = signal::from_system(|_: In<()>| 3);
 ///
 /// let sum_signal = signal::sum!(s1, s2, s3); // outputs `6`
 /// ```
@@ -3098,9 +3130,9 @@ macro_rules! __signal_reduce_binop {
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| 2);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| 3);
-/// let s3 = SignalBuilder::from_system(|_: In<()>| 4);
+/// let s1 = signal::from_system(|_: In<()>| 2);
+/// let s2 = signal::from_system(|_: In<()>| 3);
+/// let s3 = signal::from_system(|_: In<()>| 4);
 ///
 /// let product_signal = signal::product!(s1, s2, s3); // outputs `24`
 /// ```
@@ -3122,9 +3154,9 @@ macro_rules! product {
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| 5);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-/// let s3 = SignalBuilder::from_system(|_: In<()>| 7);
+/// let s1 = signal::from_system(|_: In<()>| 5);
+/// let s2 = signal::from_system(|_: In<()>| 2);
+/// let s3 = signal::from_system(|_: In<()>| 7);
 ///
 /// let min_signal = signal::min!(s1, s2, s3); // outputs `2`
 /// ```
@@ -3146,9 +3178,9 @@ macro_rules! min {
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| 5);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-/// let s3 = SignalBuilder::from_system(|_: In<()>| 7);
+/// let s1 = signal::from_system(|_: In<()>| 5);
+/// let s2 = signal::from_system(|_: In<()>| 2);
+/// let s3 = signal::from_system(|_: In<()>| 7);
 ///
 /// let max_signal = signal::max!(s1, s2, s3); // outputs `7`
 /// ```
@@ -3202,10 +3234,10 @@ macro_rules! __signal_reduce_cmp {
 /// use bevy_ecs::prelude::*;
 /// use jonmo::{prelude::*, signal};
 ///
-/// let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-/// let s2 = SignalBuilder::from_system(|_: In<()>| "hello");
-/// let s3 = SignalBuilder::from_system(|_: In<()>| 3.14);
-/// let s4 = SignalBuilder::from_system(|_: In<()>| true);
+/// let s1 = signal::from_system(|_: In<()>| 1);
+/// let s2 = signal::from_system(|_: In<()>| "hello");
+/// let s3 = signal::from_system(|_: In<()>| 3.14);
+/// let s4 = signal::from_system(|_: In<()>| true);
 ///
 /// // Outputs a flat tuple (i32, &str, f64, bool)
 /// let zipped = signal::zip!(s1, s2, s3, s4);
@@ -3265,8 +3297,8 @@ mod tests {
         JonmoPlugin,
         graph::{LazySignalHolder, SignalRegistrationCount},
         prelude::{IntoSignalVecEither, SignalVecExt, clone},
-        signal::{SignalBuilder, SignalExt, Upstream},
-        signal_vec::{MutableVec, MutableVecBuilder, VecDiff},
+        signal::{self, SignalExt, Upstream},
+        signal_vec::{MutableVec, VecDiff},
         utils::{LazyEntity, SSs},
     };
     use core::{convert::identity, fmt};
@@ -3325,7 +3357,7 @@ mod tests {
     fn test_map() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
-        let signal = SignalBuilder::from_system(|_: In<()>| 1)
+        let signal = signal::from_system(|_: In<()>| 1)
             .map(|In(x): In<i32>| x + 1)
             .map(capture_output)
             .register(app.world_mut());
@@ -3339,7 +3371,7 @@ mod tests {
         // === Part 1: Basic Infallible Mapping ===
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<String>>();
-        let signal = SignalBuilder::from_system(|_: In<()>| 10i32)
+        let signal = signal::from_system(|_: In<()>| 10i32)
             .map_in(|x: i32| format!("Value: {x}"))
             .map(capture_output)
             .register(app.world_mut());
@@ -3359,7 +3391,7 @@ mod tests {
         app.init_resource::<SignalOutput<i32>>();
         // Note: .pop() removes from the end, so the sequence is 4, 3, 2, 1
         let inputs = Arc::new(Mutex::new(vec![1, 2, 3, 4]));
-        let source_signal = SignalBuilder::from_system(clone!((inputs) move |_: In<()>| {
+        let source_signal = signal::from_system(clone!((inputs) move |_: In<()>| {
             inputs.lock().unwrap().pop()
         }));
 
@@ -3396,7 +3428,7 @@ mod tests {
         // === Part 3: FnMut Stateful Closure ===
         app.init_resource::<SignalOutput<()>>(); // We don't care about the value, just that it runs
         let call_count = Arc::new(Mutex::new(0));
-        let signal = SignalBuilder::from_system(|_: In<()>| ())
+        let signal = signal::from_system(|_: In<()>| ())
             .map_in(clone!((call_count) move |_: ()| {
                 *call_count.lock().unwrap() += 1;
             }))
@@ -3416,7 +3448,7 @@ mod tests {
 
         // === Part 4: Cleanup ===
         app.init_resource::<SignalOutput<i32>>();
-        let signal = SignalBuilder::from_system(|_: In<()>| 123)
+        let signal = signal::from_system(|_: In<()>| 123)
             .map_in(|x| x)
             .map(capture_output)
             .register(app.world_mut());
@@ -3441,7 +3473,7 @@ mod tests {
         // === Part 1: Basic Infallible Mapping ===
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<String>>();
-        let signal = SignalBuilder::from_system(|_: In<()>| 42i32)
+        let signal = signal::from_system(|_: In<()>| 42i32)
             // Use a function that takes a reference, the primary use case for map_in_ref.
             .map_in_ref(ToString::to_string)
             .map(capture_output)
@@ -3461,7 +3493,7 @@ mod tests {
         // === Part 2: Fallible Mapping (Some/None) ===
         // Note: .pop() removes from the end, so the sequence is "FOUR", "three", "TWO", "one"
         let inputs = Arc::new(Mutex::new(vec!["one", "TWO", "three", "FOUR"]));
-        let source_signal = SignalBuilder::from_system(clone!((inputs) move |_: In<()>| {
+        let source_signal = signal::from_system(clone!((inputs) move |_: In<()>| {
             inputs.lock().unwrap().pop()
         }));
 
@@ -3514,7 +3546,7 @@ mod tests {
         // === Part 3: FnMut Stateful Closure ===
         app.init_resource::<SignalOutput<()>>();
         let call_count = Arc::new(Mutex::new(0));
-        let signal = SignalBuilder::from_system(|_: In<()>| 1i32)
+        let signal = signal::from_system(|_: In<()>| 1i32)
             .map_in_ref(clone!((call_count) move |_: &i32| {
                 *call_count.lock().unwrap() += 1;
             }))
@@ -3534,7 +3566,7 @@ mod tests {
 
         // === Part 4: Cleanup ===
         app.init_resource::<SignalOutput<i32>>();
-        let signal = SignalBuilder::from_system(|_: In<()>| 123)
+        let signal = signal::from_system(|_: In<()>| 123)
             // Simple dereference to pass the value through
             .map_in_ref(|x: &i32| *x)
             .map(capture_output)
@@ -3560,7 +3592,7 @@ mod tests {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<TestData>>();
         let entity = app.world_mut().spawn(TestData(1)).id();
-        let signal = SignalBuilder::from_entity(entity)
+        let signal = signal::from_entity(entity)
             .component::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
@@ -3575,14 +3607,14 @@ mod tests {
         app.insert_resource(SignalOutput::<Option<TestData>>::default());
         let entity_with = app.world_mut().spawn(TestData(1)).id();
         let entity_without = app.world_mut().spawn_empty().id();
-        let signal = SignalBuilder::from_entity(entity_with)
+        let signal = signal::from_entity(entity_with)
             .component_option::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
         app.update();
         assert_eq!(get_output::<Option<TestData>>(app.world()), Some(Some(TestData(1))));
         signal.cleanup(app.world_mut());
-        let signal = SignalBuilder::from_entity(entity_without)
+        let signal = signal::from_entity(entity_without)
             .component_option::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
@@ -3597,14 +3629,14 @@ mod tests {
         app.insert_resource(SignalOutput::<bool>::default());
         let entity_with = app.world_mut().spawn(TestData(1)).id();
         let entity_without = app.world_mut().spawn_empty().id();
-        let signal = SignalBuilder::from_entity(entity_with)
+        let signal = signal::from_entity(entity_with)
             .has_component::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
         app.update();
         assert_eq!(get_output::<bool>(app.world()), Some(true));
         signal.cleanup(app.world_mut());
-        let signal = SignalBuilder::from_entity(entity_without)
+        let signal = signal::from_entity(entity_without)
             .has_component::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
@@ -3618,7 +3650,7 @@ mod tests {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<TestData>>();
         let entity = app.world_mut().spawn(TestData(1)).id();
-        let signal = SignalBuilder::from_entity(entity)
+        let signal = signal::from_entity(entity)
             .component_changed::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
@@ -3648,7 +3680,7 @@ mod tests {
         // Test entity without component - signal should not fire
         app.world_mut().resource_mut::<SignalOutput<TestData>>().0 = None;
         let entity_without = app.world_mut().spawn_empty().id();
-        let signal = SignalBuilder::from_entity(entity_without)
+        let signal = signal::from_entity(entity_without)
             .component_changed::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
@@ -3667,7 +3699,7 @@ mod tests {
         app.init_resource::<SignalOutput<i32>>();
         let counter = Arc::new(Mutex::new(0));
         let values = Arc::new(Mutex::new(vec![1, 1, 2, 3, 3, 3, 4]));
-        let signal = SignalBuilder::from_system(clone!((values) move |_: In<()>| {
+        let signal = signal::from_system(clone!((values) move |_: In<()>| {
             let mut values_lock = values.lock().unwrap();
             if values_lock.is_empty() {
                 None
@@ -3697,7 +3729,7 @@ mod tests {
         app.init_resource::<SignalOutput<i32>>();
         let counter = Arc::new(Mutex::new(0));
         let values = Arc::new(Mutex::new(vec![10, 20, 30]));
-        let signal = SignalBuilder::from_system(clone!((values) move |_: In<()>| {
+        let signal = signal::from_system(clone!((values) move |_: In<()>| {
             let mut values_lock = values.lock().unwrap();
             if values_lock.is_empty() {
                 None
@@ -3721,13 +3753,36 @@ mod tests {
         signal.cleanup(app.world_mut());
     }
 
+    #[test]
+    fn test_once() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<i32>>();
+        let counter = Arc::new(Mutex::new(0));
+        let signal = signal::once(42)
+            .map(clone!((counter) move |In(val): In<i32>| {
+                *counter.lock().unwrap() += 1;
+                val
+            }))
+            .map(capture_output)
+            .register(app.world_mut());
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(42));
+        assert_eq!(*counter.lock().unwrap(), 1);
+        app.update();
+        app.update();
+        // Should still be 42 and counter should still be 1 (no further emissions)
+        assert_eq!(get_output::<i32>(app.world()), Some(42));
+        assert_eq!(*counter.lock().unwrap(), 1);
+        signal.cleanup(app.world_mut());
+    }
+
     #[test]
     fn test_take() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
         let counter = Arc::new(Mutex::new(0));
         let values = Arc::new(Mutex::new(vec![10, 20, 30]));
-        let signal = SignalBuilder::from_system(clone!((values) move |_: In<()>| {
+        let signal = signal::from_system(clone!((values) move |_: In<()>| {
             let mut values_lock = values.lock().unwrap();
             if values_lock.is_empty() {
                 None
@@ -3755,8 +3810,8 @@ mod tests {
     fn test_with() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<(i32, &'static str)>>();
-        let signal = SignalBuilder::from_system(move |_: In<()>| 10)
-            .with(SignalBuilder::from_system(move |_: In<()>| "hello"))
+        let signal = signal::from_system(move |_: In<()>| 10)
+            .with(signal::from_system(move |_: In<()>| "hello"))
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -3769,16 +3824,13 @@ mod tests {
         let mut app = create_test_app();
         app.init_resource::<SignalOutputVec<(i32, i32)>>();
 
-        let left = SignalBuilder::from_system(|_: In<()>, mut state: Local<i32>| {
+        let left = signal::from_system(|_: In<()>, mut state: Local<i32>| {
             *state += 1;
             *state
         });
-        let right = SignalBuilder::from_system(|_: In<()>| 10).first();
+        let right = signal::from_system(|_: In<()>| 10).first();
 
-        let signal = left
-            .with(right)
-            .map(capture_output_vec)
-            .register(app.world_mut());
+        let signal = left.with(right).map(capture_output_vec).register(app.world_mut());
 
         app.update();
         assert_eq!(
@@ -3787,16 +3839,10 @@ mod tests {
         );
 
         app.update();
-        assert_eq!(
-            get_and_clear_output_vec::<(i32, i32)>(app.world_mut()),
-            vec![(2, 10)]
-        );
+        assert_eq!(get_and_clear_output_vec::<(i32, i32)>(app.world_mut()), vec![(2, 10)]);
 
         app.update();
-        assert_eq!(
-            get_and_clear_output_vec::<(i32, i32)>(app.world_mut()),
-            vec![(3, 10)]
-        );
+        assert_eq!(get_and_clear_output_vec::<(i32, i32)>(app.world_mut()), vec![(3, 10)]);
 
         signal.cleanup(app.world_mut());
     }
@@ -3806,7 +3852,7 @@ mod tests {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
 
-        let signal = SignalBuilder::from_system(|_: In<()>, mut state: Local<i32>| {
+        let signal = signal::from_system(|_: In<()>, mut state: Local<i32>| {
             *state += 1;
             *state
         })
@@ -3825,7 +3871,7 @@ mod tests {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<(i32, i32)>>();
 
-        let source = SignalBuilder::from_system(|_: In<()>, mut state: Local<i32>| {
+        let source = signal::from_system(|_: In<()>, mut state: Local<i32>| {
             *state += 1;
             *state
         });
@@ -3833,10 +3879,7 @@ mod tests {
         let left = source.clone().map_in(|x: i32| x + 1);
         let right = source.map_in(|x: i32| x + 10);
 
-        let signal = left
-            .with(right)
-            .map(capture_output)
-            .register(app.world_mut());
+        let signal = left.with(right).map(capture_output).register(app.world_mut());
 
         app.update();
         assert_eq!(get_output::<(i32, i32)>(app.world()), Some((2, 11)));
@@ -3849,13 +3892,11 @@ mod tests {
 
     #[test]
     fn test_zip_macro() {
-        use crate::signal::zip;
-
         let mut app = create_test_app();
 
         // Test 1 signal - returns 1-tuple
         app.init_resource::<SignalOutput<(i32,)>>();
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
+        let s1 = signal::from_system(|_: In<()>| 1);
         let signal = zip!(s1).map(capture_output).register(app.world_mut());
         app.update();
         assert_eq!(get_output::<(i32,)>(app.world()), Some((1,)));
@@ -3863,8 +3904,8 @@ mod tests {
 
         // Test 2 signals - same as .with()
         app.init_resource::<SignalOutput<(i32, &'static str)>>();
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| "two");
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| "two");
         let signal = zip!(s1, s2).map(capture_output).register(app.world_mut());
         app.update();
         assert_eq!(get_output::<(i32, &'static str)>(app.world()), Some((1, "two")));
@@ -3872,35 +3913,44 @@ mod tests {
 
         // Test 3 signals - flat tuple (not nested)
         app.init_resource::<SignalOutput<(i32, &'static str, f64)>>();
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| "two");
-        let s3 = SignalBuilder::from_system(|_: In<()>| 3.0);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| "two");
+        let s3 = signal::from_system(|_: In<()>| 3.0);
         let signal = zip!(s1, s2, s3).map(capture_output).register(app.world_mut());
         app.update();
-        assert_eq!(get_output::<(i32, &'static str, f64)>(app.world()), Some((1, "two", 3.0)));
+        assert_eq!(
+            get_output::<(i32, &'static str, f64)>(app.world()),
+            Some((1, "two", 3.0))
+        );
         signal.cleanup(app.world_mut());
 
         // Test 4 signals - verifies flattening works for more signals
         app.init_resource::<SignalOutput<(i32, &'static str, f64, bool)>>();
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| "two");
-        let s3 = SignalBuilder::from_system(|_: In<()>| 3.0);
-        let s4 = SignalBuilder::from_system(|_: In<()>| true);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| "two");
+        let s3 = signal::from_system(|_: In<()>| 3.0);
+        let s4 = signal::from_system(|_: In<()>| true);
         let signal = zip!(s1, s2, s3, s4).map(capture_output).register(app.world_mut());
         app.update();
-        assert_eq!(get_output::<(i32, &'static str, f64, bool)>(app.world()), Some((1, "two", 3.0, true)));
+        assert_eq!(
+            get_output::<(i32, &'static str, f64, bool)>(app.world()),
+            Some((1, "two", 3.0, true))
+        );
         signal.cleanup(app.world_mut());
 
         // Test 5 signals - ensures unlimited recursion works
         app.init_resource::<SignalOutput<(i32, i32, i32, i32, i32)>>();
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-        let s3 = SignalBuilder::from_system(|_: In<()>| 3);
-        let s4 = SignalBuilder::from_system(|_: In<()>| 4);
-        let s5 = SignalBuilder::from_system(|_: In<()>| 5);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| 2);
+        let s3 = signal::from_system(|_: In<()>| 3);
+        let s4 = signal::from_system(|_: In<()>| 4);
+        let s5 = signal::from_system(|_: In<()>| 5);
         let signal = zip!(s1, s2, s3, s4, s5).map(capture_output).register(app.world_mut());
         app.update();
-        assert_eq!(get_output::<(i32, i32, i32, i32, i32)>(app.world()), Some((1, 2, 3, 4, 5)));
+        assert_eq!(
+            get_output::<(i32, i32, i32, i32, i32)>(app.world()),
+            Some((1, 2, 3, 4, 5))
+        );
         signal.cleanup(app.world_mut());
     }
 
@@ -3908,14 +3958,14 @@ mod tests {
     fn test_flatten() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
-        let signal_1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let signal_2 = SignalBuilder::from_system(|_: In<()>| 2);
+        let signal_1 = signal::from_system(|_: In<()>| 1);
+        let signal_2 = signal::from_system(|_: In<()>| 2);
 
         #[derive(Resource, Default)]
         struct SignalSelector(bool);
 
         app.init_resource::<SignalSelector>();
-        let signal = SignalBuilder::from_system(
+        let signal = signal::from_system(
             move |_: In<()>, selector: Res<SignalSelector>| {
                 if selector.0 { signal_1.clone() } else { signal_2.clone() }
             },
@@ -3935,7 +3985,7 @@ mod tests {
     fn test_eq() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<bool>>();
-        let source = SignalBuilder::from_system(|_: In<()>| 1);
+        let source = signal::from_system(|_: In<()>| 1);
         let signal = source.clone().eq(1).map(capture_output).register(app.world_mut());
         app.update();
         assert_eq!(get_output::<bool>(app.world()), Some(true));
@@ -3950,7 +4000,7 @@ mod tests {
     fn test_neq() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<bool>>();
-        let source = SignalBuilder::from_system(|_: In<()>| 1);
+        let source = signal::from_system(|_: In<()>| 1);
         let signal = source.clone().neq(2).map(capture_output).register(app.world_mut());
         app.update();
         assert_eq!(get_output::<bool>(app.world()), Some(true));
@@ -3965,14 +4015,14 @@ mod tests {
     fn test_not() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<bool>>();
-        let signal = SignalBuilder::from_system(|_: In<()>| true)
+        let signal = signal::from_system(|_: In<()>| true)
             .not()
             .map(capture_output)
             .register(app.world_mut());
         app.update();
         assert_eq!(get_output::<bool>(app.world()), Some(false));
         signal.cleanup(app.world_mut());
-        let signal = SignalBuilder::from_system(|_: In<()>| false)
+        let signal = signal::from_system(|_: In<()>| false)
             .not()
             .map(capture_output)
             .register(app.world_mut());
@@ -3986,7 +4036,7 @@ mod tests {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
         let values = Arc::new(Mutex::new(vec![1, 2, 3, 4, 5, 6]));
-        let signal = SignalBuilder::from_system(move |_: In<()>| {
+        let signal = signal::from_system(move |_: In<()>| {
             let mut values_lock = values.lock().unwrap();
             if values_lock.is_empty() {
                 None
@@ -4008,14 +4058,14 @@ mod tests {
     fn test_switch() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
-        let signal_1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let signal_2 = SignalBuilder::from_system(|_: In<()>| 2);
+        let signal_1 = signal::from_system(|_: In<()>| 1);
+        let signal_2 = signal::from_system(|_: In<()>| 2);
 
         #[derive(Resource, Default)]
         struct SwitcherToggle(bool);
 
         app.init_resource::<SwitcherToggle>();
-        let signal = SignalBuilder::from_system(move |_: In<()>, mut toggle: ResMut<SwitcherToggle>| {
+        let signal = signal::from_system(move |_: In<()>, mut toggle: ResMut<SwitcherToggle>| {
             let current = toggle.0;
             toggle.0 = !toggle.0;
             current
@@ -4062,8 +4112,8 @@ mod tests {
             app.init_resource::<SignalVecOutput<i32>>();
 
             // Two different data sources to switch between.
-            let list_a = MutableVecBuilder::from([10, 20]).spawn(app.world_mut());
-            let list_b = MutableVecBuilder::from([100, 200, 300]).spawn(app.world_mut());
+            let list_a = MutableVec::builder().values([10, 20]).spawn(app.world_mut());
+            let list_b = MutableVec::builder().values([100, 200, 300]).spawn(app.world_mut());
             let signal_a = list_a.signal_vec().map_in(identity);
             let signal_b = list_b.signal_vec();
 
@@ -4077,8 +4127,7 @@ mod tests {
             app.insert_resource(ListSelector::A);
 
             // The control signal reads the resource.
-            let control_signal =
-                SignalBuilder::from_system(|_: In<()>, selector: Res<ListSelector>| *selector).dedupe();
+            let control_signal = signal::from_system(|_: In<()>, selector: Res<ListSelector>| *selector).dedupe();
 
             // The signal chain under test.
             let switched_signal = control_signal.dedupe().switch_signal_vec(
@@ -4190,7 +4239,7 @@ mod tests {
 
             // Start with an EMPTY list - this tests the `was_initially_empty` code path
             let list_a: MutableVec<i32> = app.world_mut().into();
-            let list_b = MutableVecBuilder::from([100, 200, 300]).spawn(app.world_mut());
+            let list_b = MutableVec::builder().values([100, 200, 300]).spawn(app.world_mut());
             let signal_a = list_a.signal_vec().map_in(identity);
             let signal_b = list_b.signal_vec();
 
@@ -4204,8 +4253,7 @@ mod tests {
             app.insert_resource(ListSelector::A);
 
             // The control signal reads the resource.
-            let control_signal =
-                SignalBuilder::from_system(|_: In<()>, selector: Res<ListSelector>| *selector).dedupe();
+            let control_signal = signal::from_system(|_: In<()>, selector: Res<ListSelector>| *selector).dedupe();
 
             // The signal chain under test.
             let switched_signal = control_signal.dedupe().switch_signal_vec(
@@ -4285,7 +4333,7 @@ mod tests {
 
     #[test]
     fn test_switch_signal_map() {
-        use crate::signal_map::{IntoSignalMapEither, MapDiff, MutableBTreeMapBuilder, SignalMapExt};
+        use crate::signal_map::{IntoSignalMapEither, MapDiff, MutableBTreeMap, SignalMapExt};
 
         #[derive(Resource, Default, core::fmt::Debug)]
         struct SignalMapOutput<K, V>(Vec<MapDiff<K, V>>)
@@ -4318,8 +4366,12 @@ mod tests {
             app.init_resource::<SignalMapOutput<i32, i32>>();
 
             // Two different data sources to switch between.
-            let map_a = MutableBTreeMapBuilder::from([(1, 10), (2, 20)]).spawn(app.world_mut());
-            let map_b = MutableBTreeMapBuilder::from([(1, 100), (2, 200), (3, 300)]).spawn(app.world_mut());
+            let map_a = MutableBTreeMap::builder()
+                .values([(1, 10), (2, 20)])
+                .spawn(app.world_mut());
+            let map_b = MutableBTreeMap::builder()
+                .values([(1, 100), (2, 200), (3, 300)])
+                .spawn(app.world_mut());
             let signal_a = map_a.signal_map().map_value(|In(x): In<i32>| x);
             let signal_b = map_b.signal_map();
 
@@ -4333,7 +4385,7 @@ mod tests {
             app.insert_resource(MapSelector::A);
 
             // The control signal reads the resource.
-            let control_signal = SignalBuilder::from_system(|_: In<()>, selector: Res<MapSelector>| *selector).dedupe();
+            let control_signal = signal::from_system(|_: In<()>, selector: Res<MapSelector>| *selector).dedupe();
 
             // The signal chain under test.
             let switched_signal = control_signal.dedupe().switch_signal_map(
@@ -4425,7 +4477,7 @@ mod tests {
 
     #[test]
     fn test_switch_signal_map_initially_empty() {
-        use crate::signal_map::{IntoSignalMapEither, MapDiff, MutableBTreeMap, MutableBTreeMapBuilder, SignalMapExt};
+        use crate::signal_map::{IntoSignalMapEither, MapDiff, MutableBTreeMap, SignalMapExt};
 
         #[derive(Resource, Default, core::fmt::Debug)]
         struct SignalMapOutput<K, V>(Vec<MapDiff<K, V>>)
@@ -4459,7 +4511,9 @@ mod tests {
 
             // Start with an EMPTY map - this tests the `was_initially_empty` code path
             let map_a: MutableBTreeMap<i32, i32> = app.world_mut().into();
-            let map_b = MutableBTreeMapBuilder::from([(1, 100), (2, 200), (3, 300)]).spawn(app.world_mut());
+            let map_b = MutableBTreeMap::builder()
+                .values([(1, 100), (2, 200), (3, 300)])
+                .spawn(app.world_mut());
             let signal_a = map_a.signal_map().map_value(|In(x): In<i32>| x);
             let signal_b = map_b.signal_map();
 
@@ -4473,7 +4527,7 @@ mod tests {
             app.insert_resource(MapSelector::A);
 
             // The control signal reads the resource.
-            let control_signal = SignalBuilder::from_system(|_: In<()>, selector: Res<MapSelector>| *selector).dedupe();
+            let control_signal = signal::from_system(|_: In<()>, selector: Res<MapSelector>| *selector).dedupe();
 
             // The signal chain under test.
             let switched_signal = control_signal.dedupe().switch_signal_map(
@@ -4553,7 +4607,7 @@ mod tests {
         app.init_resource::<SignalOutput<i32>>();
 
         // A simple counter to generate a new value (1, 2, 3...) for each update.
-        let source_signal = SignalBuilder::from_system(|_: In<()>, mut counter: Local<i32>| {
+        let source_signal = signal::from_system(|_: In<()>, mut counter: Local<i32>| {
             *counter += 1;
             *counter
         });
@@ -4641,7 +4695,7 @@ mod tests {
         app.init_resource::<SignalOutput<&'static str>>();
 
         // Test true case
-        let signal_true = SignalBuilder::from_system(|_: In<()>| true)
+        let signal_true = signal::from_system(|_: In<()>| true)
             .map_bool(|_: In<()>| "True Branch", |_: In<()>| "False Branch")
             .map(capture_output)
             .register(app.world_mut());
@@ -4650,7 +4704,7 @@ mod tests {
         signal_true.cleanup(app.world_mut());
 
         // Test false case
-        let signal_false = SignalBuilder::from_system(|_: In<()>| false)
+        let signal_false = signal::from_system(|_: In<()>| false)
             .map_bool(|_: In<()>| "True Branch", |_: In<()>| "False Branch")
             .map(capture_output)
             .register(app.world_mut());
@@ -4665,7 +4719,7 @@ mod tests {
         app.init_resource::<SignalOutput<Option<&'static str>>>();
 
         // --- Test true case ---
-        let source_true = SignalBuilder::from_system(|_: In<()>| true);
+        let source_true = signal::from_system(|_: In<()>| true);
         let signal_true = source_true
             .map_true(|_: In<()>| "Was True")
             .map(capture_output)
@@ -4680,7 +4734,7 @@ mod tests {
 
         // --- Test false case --- Reset output
         app.world_mut().resource_mut::<SignalOutput<Option<&'static str>>>().0 = None;
-        let source_false = SignalBuilder::from_system(|_: In<()>| false);
+        let source_false = signal::from_system(|_: In<()>| false);
         let signal_false = source_false
             .map_true(|_: In<()>| "Was True")
             .map(capture_output)
@@ -4700,7 +4754,7 @@ mod tests {
         app.init_resource::<SignalOutput<Option<&'static str>>>();
 
         // --- Test false case ---
-        let source_false = SignalBuilder::from_system(|_: In<()>| false);
+        let source_false = signal::from_system(|_: In<()>| false);
         let signal_false = source_false
             .map_false(|_: In<()>| "Was False")
             .map(capture_output)
@@ -4715,7 +4769,7 @@ mod tests {
 
         // --- Test true case --- Reset output
         app.world_mut().resource_mut::<SignalOutput<Option<&'static str>>>().0 = None;
-        let source_true = SignalBuilder::from_system(|_: In<()>| true);
+        let source_true = signal::from_system(|_: In<()>| true);
         let signal_true = source_true
             .map_false(|_: In<()>| "Was False")
             .map(capture_output)
@@ -4735,7 +4789,7 @@ mod tests {
         app.init_resource::<SignalOutput<String>>();
 
         // Test Some case
-        let signal_some = SignalBuilder::from_system(|_: In<()>| Some(42))
+        let signal_some = signal::from_system(|_: In<()>| Some(42))
             .map_option(
                 |In(value): In<i32>| format!("Some({value})"),
                 |_: In<()>| "None".to_string(),
@@ -4750,7 +4804,7 @@ mod tests {
         app.world_mut().resource_mut::<SignalOutput<String>>().0 = None;
 
         // Test None case
-        let signal_none = SignalBuilder::from_system(|_: In<()>| None::<i32>)
+        let signal_none = signal::from_system(|_: In<()>| None::<i32>)
             .map_option(
                 |In(value): In<i32>| format!("Some({value})"),
                 |_: In<()>| "None".to_string(),
@@ -4768,7 +4822,7 @@ mod tests {
         app.init_resource::<SignalOutput<Option<String>>>();
 
         // --- Test Some case ---
-        let source_some = SignalBuilder::from_system(|_: In<()>| Some(42));
+        let source_some = signal::from_system(|_: In<()>| Some(42));
         let signal_some = source_some
             .map_some(|In(val): In<i32>| format!("Got {val}"))
             .map(capture_output)
@@ -4783,7 +4837,7 @@ mod tests {
 
         // --- Test None case --- Reset output
         app.world_mut().resource_mut::<SignalOutput<Option<String>>>().0 = None;
-        let source_none = SignalBuilder::from_system(|_: In<()>| None::<i32>);
+        let source_none = signal::from_system(|_: In<()>| None::<i32>);
         let signal_none = source_none
             .map_some(|In(val): In<i32>| format!("Got {val}"))
             .map(capture_output)
@@ -4803,7 +4857,7 @@ mod tests {
         app.init_resource::<SignalOutput<Option<&'static str>>>();
 
         // --- Test None case ---
-        let source_none = SignalBuilder::from_system(|_: In<()>| None::<i32>);
+        let source_none = signal::from_system(|_: In<()>| None::<i32>);
         let signal_none = source_none
             .map_none(|_: In<()>| "Was None")
             .map(capture_output)
@@ -4818,7 +4872,7 @@ mod tests {
 
         // --- Test Some case --- Reset output
         app.world_mut().resource_mut::<SignalOutput<Option<&'static str>>>().0 = None;
-        let source_some = SignalBuilder::from_system(|_: In<()>| Some(42));
+        let source_some = signal::from_system(|_: In<()>| Some(42));
         let signal_some = source_some
             .map_none(|_: In<()>| "Was None")
             .map(capture_output)
@@ -4837,7 +4891,7 @@ mod tests {
         let mut app = create_test_app();
         app.init_resource::<SignalVecOutput<i32>>();
         let source_vec = Arc::new(Mutex::new(None::<Vec<i32>>));
-        let source_signal = SignalBuilder::from_system(clone!((source_vec) move |_: In<()>| {
+        let source_signal = signal::from_system(clone!((source_vec) move |_: In<()>| {
             source_vec.lock().unwrap().take()
         }));
         let signal_vec = source_signal.to_signal_vec();
@@ -4887,7 +4941,7 @@ mod tests {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
 
-        let signal = SignalBuilder::from_system(|_: In<()>| 42)
+        let signal = signal::from_system(|_: In<()>| 42)
             .map(capture_output)
             .register(app.world_mut());
 
@@ -4902,7 +4956,7 @@ mod tests {
         app.insert_resource(SignalOutput(Some(Entity::PLACEHOLDER)));
 
         let test_entity = app.world_mut().spawn_empty().id();
-        let signal = SignalBuilder::from_entity(test_entity)
+        let signal = signal::from_entity(test_entity)
             .map(capture_output)
             .register(app.world_mut());
 
@@ -4920,7 +4974,7 @@ mod tests {
         let test_entity = app.world_mut().spawn_empty().id();
         lazy.set(test_entity);
 
-        let signal = SignalBuilder::from_lazy_entity(lazy)
+        let signal = signal::from_lazy_entity(lazy)
             .map(capture_output)
             .register(app.world_mut());
 
@@ -4941,7 +4995,7 @@ mod tests {
         app.world_mut().entity_mut(parent).add_child(child);
 
         // Test self (generations = 0)
-        let signal_self = SignalBuilder::from_ancestor(child, 0)
+        let signal_self = signal::from_ancestor(child, 0)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -4949,7 +5003,7 @@ mod tests {
         signal_self.cleanup(app.world_mut());
 
         // Test parent (generations = 1)
-        let signal_parent = SignalBuilder::from_ancestor(child, 1)
+        let signal_parent = signal::from_ancestor(child, 1)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -4957,7 +5011,7 @@ mod tests {
         signal_parent.cleanup(app.world_mut());
 
         // Test grandparent (generations = 2)
-        let signal_gp = SignalBuilder::from_ancestor(child, 2)
+        let signal_gp = signal::from_ancestor(child, 2)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -4966,7 +5020,7 @@ mod tests {
 
         // Test invalid generation
         app.world_mut().resource_mut::<SignalOutput<Entity>>().0 = None;
-        let signal_invalid = SignalBuilder::from_ancestor(child, 3)
+        let signal_invalid = signal::from_ancestor(child, 3)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -4992,7 +5046,7 @@ mod tests {
         lazy_child.set(child);
 
         // Test parent (generations = 1)
-        let signal_parent = SignalBuilder::from_ancestor_lazy(lazy_child.clone(), 1)
+        let signal_parent = signal::from_ancestor_lazy(lazy_child.clone(), 1)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5000,7 +5054,7 @@ mod tests {
         signal_parent.cleanup(app.world_mut());
 
         // Test grandparent (generations = 2)
-        let signal_gp = SignalBuilder::from_ancestor_lazy(lazy_child, 2)
+        let signal_gp = signal::from_ancestor_lazy(lazy_child, 2)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5017,9 +5071,7 @@ mod tests {
         let child = app.world_mut().spawn_empty().id();
         app.world_mut().entity_mut(parent).add_child(child);
 
-        let signal = SignalBuilder::from_parent(child)
-            .map(capture_output)
-            .register(app.world_mut());
+        let signal = signal::from_parent(child).map(capture_output).register(app.world_mut());
         app.update();
         assert_eq!(get_output::<Entity>(app.world()), Some(parent));
         signal.cleanup(app.world_mut());
@@ -5027,7 +5079,7 @@ mod tests {
         // Test no parent
         app.world_mut().resource_mut::<SignalOutput<Entity>>().0 = None;
         let no_parent_entity = app.world_mut().spawn_empty().id();
-        let signal_no_parent = SignalBuilder::from_parent(no_parent_entity)
+        let signal_no_parent = signal::from_parent(no_parent_entity)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5050,7 +5102,7 @@ mod tests {
         app.world_mut().entity_mut(parent).add_child(child);
         lazy_child.set(child);
 
-        let signal = SignalBuilder::from_parent_lazy(lazy_child)
+        let signal = signal::from_parent_lazy(lazy_child)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5065,7 +5117,7 @@ mod tests {
 
         // Test component exists
         let entity_with = app.world_mut().spawn(TestData(42)).id();
-        let signal_with = SignalBuilder::from_component::<TestData>(entity_with)
+        let signal_with = signal::from_component::<TestData>(entity_with)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5075,7 +5127,7 @@ mod tests {
         // Test component missing
         app.world_mut().resource_mut::<SignalOutput<TestData>>().0 = None;
         let entity_without = app.world_mut().spawn_empty().id();
-        let signal_without = SignalBuilder::from_component::<TestData>(entity_without)
+        let signal_without = signal::from_component::<TestData>(entity_without)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5096,7 +5148,7 @@ mod tests {
         let entity_with = app.world_mut().spawn(TestData(42)).id();
         lazy.set(entity_with);
 
-        let signal = SignalBuilder::from_component_lazy::<TestData>(lazy)
+        let signal = signal::from_component_lazy::<TestData>(lazy)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5111,7 +5163,7 @@ mod tests {
 
         // Test component exists
         let entity_with = app.world_mut().spawn(TestData(42)).id();
-        let signal_with = SignalBuilder::from_component_option::<TestData>(entity_with)
+        let signal_with = signal::from_component_option::<TestData>(entity_with)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5120,7 +5172,7 @@ mod tests {
 
         // Test component missing
         let entity_without = app.world_mut().spawn_empty().id();
-        let signal_without = SignalBuilder::from_component_option::<TestData>(entity_without)
+        let signal_without = signal::from_component_option::<TestData>(entity_without)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5141,7 +5193,7 @@ mod tests {
         let entity_with = app.world_mut().spawn(TestData(42)).id();
         lazy.set(entity_with);
 
-        let signal = SignalBuilder::from_component_option_lazy::<TestData>(lazy)
+        let signal = signal::from_component_option_lazy::<TestData>(lazy)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5156,7 +5208,7 @@ mod tests {
 
         // Test resource exists
         app.insert_resource(TestData(42));
-        let signal_with = SignalBuilder::from_resource::<TestData>()
+        let signal_with = signal::from_resource::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5166,7 +5218,7 @@ mod tests {
         // Test resource missing
         app.world_mut().resource_mut::<SignalOutput<TestData>>().0 = None;
         app.world_mut().remove_resource::<TestData>();
-        let signal_without = SignalBuilder::from_resource::<TestData>()
+        let signal_without = signal::from_resource::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5185,7 +5237,7 @@ mod tests {
 
         // Test resource exists
         app.insert_resource(TestData(42));
-        let signal_with = SignalBuilder::from_resource_option::<TestData>()
+        let signal_with = signal::from_resource_option::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5194,7 +5246,7 @@ mod tests {
 
         // Test resource missing
         app.world_mut().remove_resource::<TestData>();
-        let signal_without = SignalBuilder::from_resource_option::<TestData>()
+        let signal_without = signal::from_resource_option::<TestData>()
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5206,13 +5258,139 @@ mod tests {
         signal_without.cleanup(app.world_mut());
     }
 
+    #[test]
+    fn test_builder_from_component_changed() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<TestData>>();
+
+        // Spawn entity with component
+        let entity = app.world_mut().spawn(TestData(42)).id();
+        let signal = signal::from_component_changed::<TestData>(entity)
+            .map(capture_output)
+            .register(app.world_mut());
+
+        // First update should emit because component was just added (Changed)
+        app.update();
+        assert_eq!(get_output::<TestData>(app.world()), Some(TestData(42)));
+
+        // Clear output and update again - should NOT emit because nothing changed
+        app.world_mut().resource_mut::<SignalOutput<TestData>>().0 = None;
+        app.update();
+        assert_eq!(
+            get_output::<TestData>(app.world()),
+            None,
+            "Should terminate when component has not changed"
+        );
+
+        // Mutate the component and update - should emit
+        app.world_mut().entity_mut(entity).get_mut::<TestData>().unwrap().0 = 100;
+        app.update();
+        assert_eq!(get_output::<TestData>(app.world()), Some(TestData(100)));
+
+        signal.cleanup(app.world_mut());
+
+        // Test component missing
+        app.world_mut().resource_mut::<SignalOutput<TestData>>().0 = None;
+        let entity_without = app.world_mut().spawn_empty().id();
+        let signal_without = signal::from_component_changed::<TestData>(entity_without)
+            .map(capture_output)
+            .register(app.world_mut());
+        app.update();
+        assert_eq!(
+            get_output::<TestData>(app.world()),
+            None,
+            "Should terminate when component is missing"
+        );
+        signal_without.cleanup(app.world_mut());
+    }
+
+    #[test]
+    fn test_builder_from_component_changed_lazy() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<TestData>>();
+
+        let lazy = LazyEntity::new();
+        let entity = app.world_mut().spawn(TestData(42)).id();
+        lazy.set(entity);
+
+        let signal = signal::from_component_changed_lazy::<TestData>(lazy)
+            .map(capture_output)
+            .register(app.world_mut());
+
+        // First update should emit because component was just added (Changed)
+        app.update();
+        assert_eq!(get_output::<TestData>(app.world()), Some(TestData(42)));
+
+        // Clear output and update again - should NOT emit because nothing changed
+        app.world_mut().resource_mut::<SignalOutput<TestData>>().0 = None;
+        app.update();
+        assert_eq!(
+            get_output::<TestData>(app.world()),
+            None,
+            "Should terminate when component has not changed"
+        );
+
+        // Mutate the component and update - should emit
+        app.world_mut().entity_mut(entity).get_mut::<TestData>().unwrap().0 = 100;
+        app.update();
+        assert_eq!(get_output::<TestData>(app.world()), Some(TestData(100)));
+
+        signal.cleanup(app.world_mut());
+    }
+
+    #[test]
+    fn test_builder_from_resource_changed() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<TestData>>();
+
+        // Insert resource
+        app.insert_resource(TestData(42));
+        let signal = signal::from_resource_changed::<TestData>()
+            .map(capture_output)
+            .register(app.world_mut());
+
+        // First update should emit because resource was just added (Changed)
+        app.update();
+        assert_eq!(get_output::<TestData>(app.world()), Some(TestData(42)));
+
+        // Clear output and update again - should NOT emit because nothing changed
+        app.world_mut().resource_mut::<SignalOutput<TestData>>().0 = None;
+        app.update();
+        assert_eq!(
+            get_output::<TestData>(app.world()),
+            None,
+            "Should terminate when resource has not changed"
+        );
+
+        // Mutate the resource and update - should emit
+        app.world_mut().resource_mut::<TestData>().0 = 100;
+        app.update();
+        assert_eq!(get_output::<TestData>(app.world()), Some(TestData(100)));
+
+        signal.cleanup(app.world_mut());
+
+        // Test resource missing
+        app.world_mut().resource_mut::<SignalOutput<TestData>>().0 = None;
+        app.world_mut().remove_resource::<TestData>();
+        let signal_without = signal::from_resource_changed::<TestData>()
+            .map(capture_output)
+            .register(app.world_mut());
+        app.update();
+        assert_eq!(
+            get_output::<TestData>(app.world()),
+            None,
+            "Should terminate when resource is missing"
+        );
+        signal_without.cleanup(app.world_mut());
+    }
+
     #[test]
     fn test_signal_option() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<Option<i32>>>();
 
         // Test Some variant - signal wrapped in Some
-        let some_signal = crate::signal::option(Some(SignalBuilder::from_system(|_: In<()>| 42)))
+        let some_signal = crate::signal::option(Some(signal::from_system(|_: In<()>| 42)))
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5239,14 +5417,13 @@ mod tests {
         // Test with dynamic signal
         app.world_mut().resource_mut::<SignalOutput<Option<i32>>>().0 = None;
         let counter = Arc::new(Mutex::new(0));
-        let dynamic_signal =
-            crate::signal::option(Some(SignalBuilder::from_system(clone!((counter) move |_: In<()>| {
-                let mut c = counter.lock().unwrap();
-                *c += 1;
-                *c
-            }))))
-            .map(capture_output)
-            .register(app.world_mut());
+        let dynamic_signal = crate::signal::option(Some(signal::from_system(clone!((counter) move |_: In<()>| {
+            let mut c = counter.lock().unwrap();
+            *c += 1;
+            *c
+        }))))
+        .map(capture_output)
+        .register(app.world_mut());
 
         app.update();
         assert_eq!(get_output::<Option<i32>>(app.world()), Some(Some(1)));
@@ -5264,12 +5441,12 @@ mod tests {
 
         // Test switching between Some and None based on a condition
         let condition = Arc::new(Mutex::new(true));
-        let signal = SignalBuilder::from_system(clone!((condition) move |_: In<()>| {
+        let signal = signal::from_system(clone!((condition) move |_: In<()>| {
             *condition.lock().unwrap()
         }))
         .map(move |In(use_signal): In<bool>| {
             if use_signal {
-                crate::signal::option(Some(SignalBuilder::from_system(|_: In<()>| 42)))
+                crate::signal::option(Some(signal::from_system(|_: In<()>| 42)))
             } else {
                 crate::signal::option(None)
             }
@@ -5310,7 +5487,7 @@ mod tests {
     #[test]
     fn simple_signal_lazy_outlives_handle() {
         let mut app = create_test_app();
-        let source_signal_struct = SignalBuilder::from_system(|_: In<()>| 1);
+        let source_signal_struct = signal::from_system(|_: In<()>| 1);
         let handle = source_signal_struct.clone().register(app.world_mut());
         let system_entity = handle.0.entity();
         assert!(
@@ -5365,7 +5542,7 @@ mod tests {
         let mut app = create_test_app();
 
         // LS.state_refs = 1
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
+        let s1 = signal::from_system(|_: In<()>| 1);
 
         // LS.state_refs = 2
         let s2 = s1.clone();
@@ -5406,7 +5583,7 @@ mod tests {
         let mut app = create_test_app();
 
         // LS.state_refs = 1
-        let source_signal_struct = SignalBuilder::from_system(|_: In<()>| 1);
+        let source_signal_struct = signal::from_system(|_: In<()>| 1);
 
         // LS.state_refs = 2 (struct, holder). RegCount = 1.
         let handle1 = source_signal_struct.clone().register(app.world_mut());
@@ -5439,7 +5616,7 @@ mod tests {
     #[test]
     fn chained_signals_cleanup() {
         let mut app = create_test_app();
-        let source_s = SignalBuilder::from_system(|_: In<()>| 1);
+        let source_s = signal::from_system(|_: In<()>| 1);
 
         // map_s holds source_s
         let map_s = source_s.map(|In(val)| val + 1);
@@ -5487,7 +5664,7 @@ mod tests {
         let mut app = create_test_app();
 
         // LS.state_refs = 1
-        let source_signal_struct = SignalBuilder::from_system(|_: In<()>| 1);
+        let source_signal_struct = signal::from_system(|_: In<()>| 1);
 
         // LS.state_refs = 2 (struct, holder). RegCount = 1.
         let handle1 = source_signal_struct.clone().register(app.world_mut());
@@ -5522,10 +5699,10 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<bool>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s3 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s4 = SignalBuilder::from_system(|_: In<()>| 2);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| 1);
+        let s3 = signal::from_system(|_: In<()>| 1);
+        let s4 = signal::from_system(|_: In<()>| 2);
 
         // Test equality
         let eq_signal = crate::signal::eq!(s1.clone(), s2.clone(), s3.clone());
@@ -5545,8 +5722,8 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<bool>::default());
 
-        let t = SignalBuilder::from_system(|_: In<()>| true);
-        let f = SignalBuilder::from_system(|_: In<()>| false);
+        let t = signal::from_system(|_: In<()>| true);
+        let f = signal::from_system(|_: In<()>| false);
 
         // Test AND (all true)
         let all_signal = crate::signal::all!(t.clone(), t.clone(), t.clone());
@@ -5566,8 +5743,8 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<bool>::default());
 
-        let t = SignalBuilder::from_system(|_: In<()>| true);
-        let f = SignalBuilder::from_system(|_: In<()>| false);
+        let t = signal::from_system(|_: In<()>| true);
+        let f = signal::from_system(|_: In<()>| false);
 
         // Test OR (all false)
         let any_signal = crate::signal::any!(f.clone(), f.clone(), f.clone());
@@ -5587,9 +5764,9 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<bool>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-        let s3 = SignalBuilder::from_system(|_: In<()>| 3);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| 2);
+        let s3 = signal::from_system(|_: In<()>| 3);
 
         // Test distinct (all different)
         let distinct_signal = crate::signal::distinct!(s1.clone(), s2.clone(), s3.clone());
@@ -5601,8 +5778,8 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<bool>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| 2);
 
         let distinct_signal = crate::signal::distinct!(s1.clone(), s2.clone(), s1.clone());
         distinct_signal.map(capture_output::<bool>).register(app.world_mut());
@@ -5615,8 +5792,8 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| 2);
 
         // Test sum with 2 signals
         let sum_signal = crate::signal::sum!(s1, s2);
@@ -5628,10 +5805,10 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-        let s3 = SignalBuilder::from_system(|_: In<()>| 3);
-        let s4 = SignalBuilder::from_system(|_: In<()>| 4);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| 2);
+        let s3 = signal::from_system(|_: In<()>| 3);
+        let s4 = signal::from_system(|_: In<()>| 4);
 
         let sum_signal = crate::signal::sum!(s1, s2, s3, s4);
         sum_signal.map(capture_output::<i32>).register(app.world_mut());
@@ -5644,8 +5821,8 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 2);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 3);
+        let s1 = signal::from_system(|_: In<()>| 2);
+        let s2 = signal::from_system(|_: In<()>| 3);
 
         // Test product with 2 signals
         let product_signal = crate::signal::product!(s1, s2);
@@ -5657,10 +5834,10 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 1);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-        let s3 = SignalBuilder::from_system(|_: In<()>| 3);
-        let s4 = SignalBuilder::from_system(|_: In<()>| 4);
+        let s1 = signal::from_system(|_: In<()>| 1);
+        let s2 = signal::from_system(|_: In<()>| 2);
+        let s3 = signal::from_system(|_: In<()>| 3);
+        let s4 = signal::from_system(|_: In<()>| 4);
 
         let product_signal = crate::signal::product!(s1, s2, s3, s4);
         product_signal.map(capture_output::<i32>).register(app.world_mut());
@@ -5673,8 +5850,8 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 5);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
+        let s1 = signal::from_system(|_: In<()>| 5);
+        let s2 = signal::from_system(|_: In<()>| 2);
 
         // Test min with 2 signals
         let min_signal = crate::signal::min!(s1, s2);
@@ -5686,10 +5863,10 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 10);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-        let s3 = SignalBuilder::from_system(|_: In<()>| 7);
-        let s4 = SignalBuilder::from_system(|_: In<()>| 3);
+        let s1 = signal::from_system(|_: In<()>| 10);
+        let s2 = signal::from_system(|_: In<()>| 2);
+        let s3 = signal::from_system(|_: In<()>| 7);
+        let s4 = signal::from_system(|_: In<()>| 3);
 
         let min_signal = crate::signal::min!(s1, s2, s3, s4);
         min_signal.map(capture_output::<i32>).register(app.world_mut());
@@ -5702,8 +5879,8 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 5);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
+        let s1 = signal::from_system(|_: In<()>| 5);
+        let s2 = signal::from_system(|_: In<()>| 2);
 
         // Test max with 2 signals
         let max_signal = crate::signal::max!(s1, s2);
@@ -5715,10 +5892,10 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let s1 = SignalBuilder::from_system(|_: In<()>| 10);
-        let s2 = SignalBuilder::from_system(|_: In<()>| 2);
-        let s3 = SignalBuilder::from_system(|_: In<()>| 7);
-        let s4 = SignalBuilder::from_system(|_: In<()>| 3);
+        let s1 = signal::from_system(|_: In<()>| 10);
+        let s2 = signal::from_system(|_: In<()>| 2);
+        let s3 = signal::from_system(|_: In<()>| 7);
+        let s4 = signal::from_system(|_: In<()>| 3);
 
         let max_signal = crate::signal::max!(s1, s2, s3, s4);
         max_signal.map(capture_output::<i32>).register(app.world_mut());
@@ -5731,7 +5908,7 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<&'static str>::default());
 
-        let signal = SignalBuilder::from_system({
+        let signal = signal::from_system({
             move |_: In<()>, mut state: Local<bool>| {
                 *state = !*state;
                 *state
@@ -5760,7 +5937,7 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let signal = SignalBuilder::from_system({
+        let signal = signal::from_system({
             move |_: In<()>, mut state: Local<bool>| {
                 *state = !*state;
                 *state
@@ -5793,7 +5970,7 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<Option<i32>>::default());
 
-        let signal = SignalBuilder::from_system({
+        let signal = signal::from_system({
             move |_: In<()>, mut state: Local<bool>| {
                 *state = !*state;
                 *state
@@ -5821,7 +5998,7 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<Option<i32>>::default());
 
-        let signal = SignalBuilder::from_system({
+        let signal = signal::from_system({
             move |_: In<()>, mut state: Local<bool>| {
                 *state = !*state;
                 *state
@@ -5849,7 +6026,7 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<i32>::default());
 
-        let signal = SignalBuilder::from_system({
+        let signal = signal::from_system({
             move |_: In<()>, mut state: Local<Option<i32>>| {
                 *state = match *state {
                     None => Some(10),
@@ -5886,7 +6063,7 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<Option<i32>>::default());
 
-        let signal = SignalBuilder::from_system({
+        let signal = signal::from_system({
             move |_: In<()>, mut state: Local<Option<i32>>| {
                 *state = if state.is_some() { None } else { Some(42) };
                 *state
@@ -5914,7 +6091,7 @@ mod tests {
         let mut app = create_test_app();
         app.insert_resource(SignalOutput::<Option<i32>>::default());
 
-        let signal = SignalBuilder::from_system({
+        let signal = signal::from_system({
             move |_: In<()>, mut state: Local<Option<i32>>| {
                 *state = if state.is_some() { None } else { Some(100) };
                 *state
diff --git a/src/signal_map.rs b/src/signal_map.rs
index 784606e..25bc47e 100644
--- a/src/signal_map.rs
+++ b/src/signal_map.rs
@@ -5,7 +5,7 @@ use super::{
         LazySignal, SignalHandle, SignalHandles, SignalSystem, downcast_any_clone, lazy_signal_from_system,
         pipe_signal, poll_signal, process_signals, register_signal,
     },
-    signal::{Signal, SignalBuilder, SignalExt},
+    signal::{self, Signal, SignalExt},
     signal_vec::{ReplayOnce, Replayable, SignalVec, VecDiff},
     utils::{LazyEntity, SSs},
 };
@@ -22,7 +22,7 @@ use core::{
     fmt,
     marker::PhantomData,
     ops::Deref,
-    sync::atomic::{AtomicUsize, Ordering as AtomicOrdering},
+    sync::atomic::{self, AtomicUsize},
 };
 use dyn_clone::{DynClone, clone_trait_object};
 
@@ -450,10 +450,12 @@ where
     /// let mut world = World::new();
     /// world.insert_resource(DoubleValues(true));
     ///
-    /// let map = MutableBTreeMapBuilder::from([(1, 10), (2, 20)]).spawn(&mut world);
+    /// let map = MutableBTreeMap::builder()
+    ///     .values([(1, 10), (2, 20)])
+    ///     .spawn(&mut world);
     ///
-    /// let signal = SignalBuilder::from_system(|_: In<()>, res: Res<DoubleValues>| res.0)
-    ///     .switch_signal_map(move |In(double): In<bool>, world: &mut World| {
+    /// let signal = signal::from_system(|_: In<()>, res: Res<DoubleValues>| res.0).switch_signal_map(
+    ///     move |In(double): In<bool>, world: &mut World| {
     ///         if double {
     ///             map.signal_map()
     ///                 .map_value(|In(v): In<i32>| v * 2)
@@ -461,7 +463,8 @@ where
     ///         } else {
     ///             map.signal_map().right_either()
     ///         }
-    ///     });
+    ///     },
+    /// );
     /// // both branches produce compatible SignalMapEither types
     /// ```
     fn left_either<R>(self) -> SignalMapEither<Self, R>
@@ -489,11 +492,15 @@ where
     /// let mut world = World::new();
     /// world.insert_resource(MapSelector(false));
     ///
-    /// let map_a = MutableBTreeMapBuilder::from([(1, 10), (2, 20)]).spawn(&mut world);
-    /// let map_b = MutableBTreeMapBuilder::from([(1, 100), (2, 200), (3, 300)]).spawn(&mut world);
+    /// let map_a = MutableBTreeMap::builder()
+    ///     .values([(1, 10), (2, 20)])
+    ///     .spawn(&mut world);
+    /// let map_b = MutableBTreeMap::builder()
+    ///     .values([(1, 100), (2, 200), (3, 300)])
+    ///     .spawn(&mut world);
     ///
-    /// let signal = SignalBuilder::from_system(|_: In<()>, res: Res<MapSelector>| res.0)
-    ///     .switch_signal_map(move |In(use_a): In<bool>, world: &mut World| {
+    /// let signal = signal::from_system(|_: In<()>, res: Res<MapSelector>| res.0).switch_signal_map(
+    ///     move |In(use_a): In<bool>, world: &mut World| {
     ///         if use_a {
     ///             map_a
     ///                 .signal_map()
@@ -502,7 +509,8 @@ where
     ///         } else {
     ///             map_b.signal_map().right_either()
     ///         }
-    ///     });
+    ///     },
+    /// );
     /// // both branches produce compatible SignalMapEither types
     /// ```
     fn right_either<L>(self) -> SignalMapEither<L, Self>
@@ -549,7 +557,8 @@ pub trait SignalMapExt: SignalMap {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    /// MutableBTreeMap::builder()
+    ///     .values([(1, 2), (3, 4)])
     ///     .spawn(&mut world)
     ///     .signal_map()
     ///     .map_value(|In(x)| x * 2); // outputs `SignalMap -> {1: 2, 3: 4}`
@@ -595,11 +604,11 @@ pub trait SignalMapExt: SignalMap {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    /// MutableBTreeMap::builder().values([(1, 2), (3, 4)])
     ///     .spawn(&mut world)
     ///     .signal_map()
     ///     .map_value_signal(|In(x)|
-    ///         SignalBuilder::from_system(move |_: In<()>| x * 2).dedupe()
+    ///         signal::from_system(move |_: In<()>| x * 2).dedupe()
     ///     ); // outputs `SignalMap -> {1: 4, 3: 8}`
     /// ```
     fn map_value_signal<S, F, M>(self, system: F) -> MapValueSignal<Self, S>
@@ -617,17 +626,13 @@ pub trait SignalMapExt: SignalMap {
         let signal = LazySignal::new(move |world: &mut World| {
             let factory_system_id = world.register_system(system);
             let output_signal_entity = LazyEntity::new();
-            let output_signal = *SignalBuilder::from_system::<Vec<MapDiff<Self::Key, S::Item>>, _, _, _>(
+            let output_signal = *signal::from_system::<Vec<MapDiff<Self::Key, S::Item>>, _, _, _>(
                 clone!((output_signal_entity) move |_: In<()>, world: &mut World| {
-                    if let Some(mut diffs) = world.get_mut::<QueuedMapDiffs<Self::Key, S::Item>>(output_signal_entity.get())
-                    {
-                        if diffs.0.is_empty() {
-                            None
-                        } else {
-                            Some(diffs.0.drain(..).collect())
-                        }
-                    } else {
+                    let mut diffs = world.get_mut::<QueuedMapDiffs<Self::Key, S::Item>>(*output_signal_entity).unwrap();
+                    if diffs.0.is_empty() {
                         None
+                    } else {
+                        Some(diffs.0.drain(..).collect())
                     }
                 }),
             )
@@ -648,13 +653,15 @@ pub trait SignalMapExt: SignalMap {
                 temp_handle.cleanup(world);
                 let processor_handle = inner_signal
                     .map(move |In(value): In<V>, world: &mut World| {
-                        if let Some(mut queue) = world.get_mut::<QueuedMapDiffs<K, V>>(*output_signal) {
-                            queue.0.push(MapDiff::Update {
+                        world
+                            .get_mut::<QueuedMapDiffs<K, V>>(*output_signal)
+                            .unwrap()
+                            .0
+                            .push(MapDiff::Update {
                                 key: key.clone(),
                                 value,
                             });
-                            process_signals(world, [output_signal], Box::new(()));
-                        }
+                        process_signals(world, [output_signal], Box::new(()));
                     })
                     .register(world);
                 (processor_handle, *inner_signal_id, initial_value)
@@ -774,10 +781,12 @@ pub trait SignalMapExt: SignalMap {
                         }
                     }
                 }
-                if !new_map_diffs.is_empty()
-                    && let Some(mut queue) = world.get_mut::<QueuedMapDiffs<Self::Key, S::Item>>(*output_signal)
-                {
-                    queue.0.extend(new_map_diffs);
+                if !new_map_diffs.is_empty() {
+                    world
+                        .get_mut::<QueuedMapDiffs<Self::Key, S::Item>>(*output_signal)
+                        .unwrap()
+                        .0
+                        .extend(new_map_diffs);
                 }
                 process_signals(world, [output_signal], Box::new(()));
             };
@@ -812,7 +821,8 @@ pub trait SignalMapExt: SignalMap {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    /// MutableBTreeMap::builder()
+    ///     .values([(1, 2), (3, 4)])
     ///     .spawn(&mut world)
     ///     .signal_map()
     ///     .key(1); // outputs `2`
@@ -874,7 +884,9 @@ pub trait SignalMapExt: SignalMap {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut map = MutableBTreeMapBuilder::from([(1, 2), (3, 4)]).spawn(&mut world);
+    /// let mut map = MutableBTreeMap::builder()
+    ///     .values([(1, 2), (3, 4)])
+    ///     .spawn(&mut world);
     /// let signal = map.signal_map().debug();
     /// // `signal` logs `[ Replace { entries: [ (1, 2), (3, 4) ] } ]`
     /// map.write(&mut world).insert(5, 6);
@@ -907,16 +919,18 @@ pub trait SignalMapExt: SignalMap {
     /// let mut world = World::new();
     /// let condition = true;
     /// let signal = if condition {
-    ///     MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///     MutableBTreeMap::builder()
+    ///         .values([(1, 2), (3, 4)])
     ///         .spawn(&mut world)
     ///         .signal_map()
     ///         .map_value(|In(x): In<i32>| x * 2)
     ///         .boxed() // this is a `MapValue<Source<i32, i32>>`
     /// } else {
-    ///     MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///     MutableBTreeMap::builder()
+    ///         .values([(1, 2), (3, 4)])
     ///         .spawn(&mut world)
     ///         .signal_map()
-    ///         .map_value_signal(|In(x): In<i32>| SignalBuilder::from_system(move |_: In<()>| x * 2))
+    ///         .map_value_signal(|In(x): In<i32>| signal::from_system(move |_: In<()>| x * 2))
     ///         .boxed() // this is a `MapValueSignal<Source<i32, i32>>`
     /// }; // without the `.boxed()`, the compiler would not allow this
     /// ```
@@ -937,21 +951,21 @@ pub trait SignalMapExt: SignalMap {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system(|_: In<()>| true).switch_signal_map(
+    /// signal::from_system(|_: In<()>| true).switch_signal_map(
     ///     |In(condition): In<bool>, world: &mut World| {
     ///         if condition {
-    ///             MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///             MutableBTreeMap::builder()
+    ///                 .values([(1, 2), (3, 4)])
     ///                 .spawn(world)
     ///                 .signal_map()
     ///                 .map_value(|In(x): In<i32>| x * 2)
     ///                 .boxed_clone() // this is a `MapValue<Source<i32, i32>>`
     ///         } else {
-    ///             MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///             MutableBTreeMap::builder()
+    ///                 .values([(1, 2), (3, 4)])
     ///                 .spawn(world)
     ///                 .signal_map()
-    ///                 .map_value_signal(|In(x): In<i32>| {
-    ///                     SignalBuilder::from_system(move |_: In<()>| x * 2)
-    ///                 })
+    ///                 .map_value_signal(|In(x): In<i32>| signal::from_system(move |_: In<()>| x * 2))
     ///                 .boxed_clone() // this is a `MapValueSignal<Source<i32, i32>>`
     ///         } // without the `.boxed_clone()`, the compiler would not allow this
     ///     },
@@ -1088,7 +1102,7 @@ pub struct MutableBTreeMap<K, V> {
 
 impl<K, V> Clone for MutableBTreeMap<K, V> {
     fn clone(&self) -> Self {
-        self.references.fetch_add(1, AtomicOrdering::SeqCst);
+        self.references.fetch_add(1, atomic::Ordering::Relaxed);
         Self {
             entity: self.entity,
             references: self.references.clone(),
@@ -1099,7 +1113,7 @@ impl<K, V> Clone for MutableBTreeMap<K, V> {
 
 impl<K, V> Drop for MutableBTreeMap<K, V> {
     fn drop(&mut self) {
-        if self.references.fetch_sub(1, AtomicOrdering::SeqCst) == 1 {
+        if self.references.fetch_sub(1, atomic::Ordering::Relaxed) == 1 {
             STALE_MUTABLE_BTREE_MAPS.lock().unwrap().push(self.entity);
         }
     }
@@ -1172,6 +1186,32 @@ where
 }
 
 impl<K, V> MutableBTreeMap<K, V> {
+    /// Creates a [`Builder`] for constructing a [`MutableBTreeMap`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// let mut world = World::new();
+    /// // Empty MutableBTreeMap
+    /// let map = MutableBTreeMap::<i32, &str>::builder().spawn(&mut world);
+    /// // With initial values
+    /// let map = MutableBTreeMap::builder()
+    ///     .values([(1, "one"), (2, "two")])
+    ///     .spawn(&mut world);
+    /// // With custom initialization
+    /// let map = MutableBTreeMap::builder()
+    ///     .with_values(|m| {
+    ///         m.insert(1, "one");
+    ///     })
+    ///     .spawn(&mut world);
+    /// ```
+    pub fn builder() -> Builder<K, V> {
+        Builder::new()
+    }
+
     /// Provides read-only access to the underlying [`BTreeMap`] via either a `&World` or a
     /// `&Query<MutableBTreeMapData<K, V>>`.
     pub fn read<'s>(
@@ -1218,15 +1258,12 @@ impl<K, V> MutableBTreeMap<K, V> {
                 if replay_onces.contains(*replay_entity) {
                     let first_replay = !core::mem::replace(&mut *has_replayed, true);
                     if first_replay && was_initially_empty {
-                        // Initial replay with empty map - just forward upstream diffs
                         if upstream_diffs.is_empty() {
                             None
                         } else {
                             Some(upstream_diffs)
                         }
                     } else {
-                        // Either non-empty initial state, or subsequent replay (e.g., switch_signal_map)
-                        // Always emit Replace with current state
                         let current_map = self_.read(&mutable_btree_map_datas);
                         if current_map.is_empty() {
                             None
@@ -1393,11 +1430,76 @@ where
     }
 }
 
-/// Builder for constructing a [`MutableBTreeMap`] with initial values, e.g.
-/// `MutableBTreeMapBuilder::from([(0, 1), (1, 2)]).spawn(&mut World)`.
-pub struct MutableBTreeMapBuilder<K, V>(BTreeMap<K, V>);
+/// Builder for constructing a [`MutableBTreeMap`].
+///
+/// # Example
+///
+/// ```
+/// use bevy_ecs::prelude::*;
+/// use jonmo::prelude::*;
+///
+/// let mut world = World::new();
+/// let map = MutableBTreeMap::builder()
+///     .values([(1, "one"), (2, "two")])
+///     .spawn(&mut world);
+/// ```
+pub struct Builder<K, V>(BTreeMap<K, V>);
+
+impl<K, V> Default for Builder<K, V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<K, V> Builder<K, V> {
+    /// Creates a new empty builder.
+    pub fn new() -> Self {
+        Self(BTreeMap::new())
+    }
+}
+
+impl<K: Ord, V> Builder<K, V> {
+    /// Sets the initial values of the [`MutableBTreeMap`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// let mut world = World::new();
+    /// let map = MutableBTreeMap::builder()
+    ///     .values([(1, "one")])
+    ///     .spawn(&mut world);
+    /// ```
+    pub fn values(mut self, values: impl Into<BTreeMap<K, V>>) -> Self {
+        self.0 = values.into();
+        self
+    }
+
+    /// Mutably access the inner [`BTreeMap`] for custom initialization.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// let mut world = World::new();
+    /// let map = MutableBTreeMap::builder()
+    ///     .with_values(|m| {
+    ///         m.insert(1, "one");
+    ///         m.insert(2, "two");
+    ///     })
+    ///     .spawn(&mut world);
+    /// ```
+    pub fn with_values(mut self, f: impl FnOnce(&mut BTreeMap<K, V>)) -> Self {
+        f(&mut self.0);
+        self
+    }
+}
 
-impl<K, V, A> From<A> for MutableBTreeMapBuilder<K, V>
+impl<K, V, A> From<A> for Builder<K, V>
 where
     BTreeMap<K, V>: From<A>,
 {
@@ -1406,7 +1508,7 @@ where
     }
 }
 
-impl<K, V> MutableBTreeMapBuilder<K, V>
+impl<K, V> Builder<K, V>
 where
     K: Ord + Clone + SSs,
     V: Clone + SSs,
@@ -1603,8 +1705,8 @@ pub(crate) mod tests {
 
             // The output of our `for_each` system will be the full, reconstructed BTreeMap.
             app.init_resource::<SignalOutput<BTreeMap<u32, String>>>();
-            let source_map =
-                (MutableBTreeMapBuilder::from([(1, "one".to_string()), (2, "two".to_string())])).spawn(app.world_mut());
+            let source_map = (MutableBTreeMap::builder().values([(1, "one".to_string()), (2, "two".to_string())]))
+                .spawn(app.world_mut());
 
             // This system reconstructs the state of the map by applying the diffs it
             // receives. It then outputs the complete, current state of the map. This allows
@@ -1696,7 +1798,7 @@ pub(crate) mod tests {
             app.init_resource::<SignalMapOutput<u32, String>>();
 
             // The source map contains integer values.
-            let source_map = (MutableBTreeMapBuilder::from([(1, 10), (2, 20)])).spawn(app.world_mut());
+            let source_map = (MutableBTreeMap::builder().values([(1, 10), (2, 20)])).spawn(app.world_mut());
 
             // The mapping function transforms an i32 value into a String.
             let mapping_system = |In(val): In<i32>| format!("Val:{val}");
@@ -1788,11 +1890,11 @@ pub(crate) mod tests {
 
             // The source map contains entities. The goal is to create a derived map that
             // contains the _names_ of these entities.
-            let entity_map = (MutableBTreeMapBuilder::from([(1, entity_a), (2, entity_b)])).spawn(app.world_mut());
+            let entity_map = (MutableBTreeMap::builder().values([(1, entity_a), (2, entity_b)])).spawn(app.world_mut());
 
             // This "factory" system takes an entity and creates a signal that tracks its
             // `Name`.
-            let factory_system = |In(entity): In<Entity>| SignalBuilder::from_component::<Name>(entity).dedupe();
+            let factory_system = |In(entity): In<Entity>| signal::from_component::<Name>(entity).dedupe();
 
             // Apply `map_value_signal` to transform the SignalMap<u32, Entity> into a
             // SignalMap<u32, Name>.
@@ -1947,8 +2049,8 @@ pub(crate) mod tests {
 
             // The output is a Signal<Option`<String>`>.
             app.init_resource::<SignalOutput<Option<String>>>();
-            let source_map =
-                (MutableBTreeMapBuilder::from([(1, "one".to_string()), (2, "two".to_string())])).spawn(app.world_mut());
+            let source_map = (MutableBTreeMap::builder().values([(1, "one".to_string()), (2, "two".to_string())]))
+                .spawn(app.world_mut());
 
             // We will specifically track the value associated with key `2`.
             let key_to_track = 2;
@@ -2066,7 +2168,7 @@ pub(crate) mod tests {
             app.init_resource::<SignalVecOutput<u32>>(); // Keys are u32
 
             // Start with unsorted data to verify initial sort.
-            let source_map = (MutableBTreeMapBuilder::from([(3, 'c'), (1, 'a'), (4, 'd')])).spawn(app.world_mut());
+            let source_map = (MutableBTreeMap::builder().values([(3, 'c'), (1, 'a'), (4, 'd')])).spawn(app.world_mut());
 
             let keys_signal = source_map.signal_vec_keys();
             let handle = keys_signal
@@ -2169,7 +2271,7 @@ pub(crate) mod tests {
             app.init_resource::<SignalVecOutput<(u32, char)>>(); // Entries are (u32, char)
 
             // Start with unsorted data to verify initial sort.
-            let source_map = (MutableBTreeMapBuilder::from([(3, 'c'), (1, 'a'), (4, 'd')])).spawn(app.world_mut());
+            let source_map = (MutableBTreeMap::builder().values([(3, 'c'), (1, 'a'), (4, 'd')])).spawn(app.world_mut());
 
             let entries_signal = source_map.signal_vec_entries();
             let handle = entries_signal
@@ -2343,9 +2445,9 @@ pub(crate) mod tests {
             app.init_resource::<SignalMapOutput<String, i32>>();
 
             // Start with a map containing initial entries
-            let source_map =
-                MutableBTreeMapBuilder::from([("x".to_string(), 1), ("y".to_string(), 2), ("z".to_string(), 3)])
-                    .spawn(app.world_mut());
+            let source_map = MutableBTreeMap::builder()
+                .values([("x".to_string(), 1), ("y".to_string(), 2), ("z".to_string(), 3)])
+                .spawn(app.world_mut());
 
             // Create a signal_map and register it
             let signal = source_map.signal_map();
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index f5c85f3..a549b1a 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -5,7 +5,7 @@ use super::{
         LazySignal, SignalHandle, SignalHandles, SignalSystem, Upstream, downcast_any_clone, lazy_signal_from_system,
         pipe_signal, poll_signal, process_signals, register_signal,
     },
-    signal::{Signal, SignalBuilder, SignalExt},
+    signal::{self, Signal, SignalExt},
     utils::{LazyEntity, SSs},
 };
 use crate::prelude::clone;
@@ -23,7 +23,7 @@ use core::{
     fmt,
     marker::PhantomData,
     ops::Deref,
-    sync::atomic::{AtomicUsize, Ordering as AtomicOrdering},
+    sync::atomic::{self, AtomicUsize},
 };
 use dyn_clone::{DynClone, clone_trait_object};
 
@@ -991,10 +991,12 @@ where
     /// let mut world = World::new();
     /// world.insert_resource(ShowFiltered(true));
     ///
-    /// let list = MutableVecBuilder::from([1, 2, 3, 4, 5]).spawn(&mut world);
+    /// let list = MutableVec::builder()
+    ///     .values([1, 2, 3, 4, 5])
+    ///     .spawn(&mut world);
     ///
-    /// let signal = SignalBuilder::from_system(|_: In<()>, res: Res<ShowFiltered>| res.0)
-    ///     .switch_signal_vec(move |In(show_filtered): In<bool>, world: &mut World| {
+    /// let signal = signal::from_system(|_: In<()>, res: Res<ShowFiltered>| res.0).switch_signal_vec(
+    ///     move |In(show_filtered): In<bool>, world: &mut World| {
     ///         if show_filtered {
     ///             list.signal_vec()
     ///                 .filter(|In(x): In<i32>| x % 2 == 0)
@@ -1002,7 +1004,8 @@ where
     ///         } else {
     ///             list.signal_vec().right_either()
     ///         }
-    ///     });
+    ///     },
+    /// );
     /// // both branches produce compatible SignalVecEither types
     /// ```
     fn left_either<R>(self) -> SignalVecEither<Self, R>
@@ -1030,17 +1033,20 @@ where
     /// let mut world = World::new();
     /// world.insert_resource(ListMode(0));
     ///
-    /// let list_a = MutableVecBuilder::from([10, 20]).spawn(&mut world);
-    /// let list_b = MutableVecBuilder::from([100, 200, 300]).spawn(&mut world);
+    /// let list_a = MutableVec::builder().values([10, 20]).spawn(&mut world);
+    /// let list_b = MutableVec::builder()
+    ///     .values([100, 200, 300])
+    ///     .spawn(&mut world);
     ///
-    /// let signal = SignalBuilder::from_system(|_: In<()>, res: Res<ListMode>| res.0)
-    ///     .switch_signal_vec(move |In(mode): In<u8>, world: &mut World| {
+    /// let signal = signal::from_system(|_: In<()>, res: Res<ListMode>| res.0).switch_signal_vec(
+    ///     move |In(mode): In<u8>, world: &mut World| {
     ///         if mode == 0 {
     ///             list_a.signal_vec().map_in(|x: i32| x * 2).left_either()
     ///         } else {
     ///             list_b.signal_vec().right_either()
     ///         }
-    ///     });
+    ///     },
+    /// );
     /// // both branches produce compatible SignalVecEither types
     /// ```
     fn right_either<L>(self) -> SignalVecEither<L, Self>
@@ -1086,7 +1092,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3])
+    /// MutableVec::builder()
+    ///     .values([1, 2, 3])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .map(|In(x): In<i32>| x * 2); // outputs `SignalVec -> [2, 4, 6]`
@@ -1169,7 +1176,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3])
+    /// MutableVec::builder()
+    ///     .values([1, 2, 3])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .map_in(|x: i32| x * 2); // outputs `SignalVec -> [2, 4, 6]`
@@ -1197,7 +1205,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3])
+    /// MutableVec::builder()
+    ///     .values([1, 2, 3])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .map_in_ref(ToString::to_string); // outputs `SignalVec -> ["1", "2", "3"]`
@@ -1222,11 +1231,11 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3])
+    /// MutableVec::builder().values([1, 2, 3])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .map_signal(|In(x): In<i32>|
-    ///         SignalBuilder::from_system(move |_: In<()>| x * 2).dedupe()
+    ///         signal::from_system(move |_: In<()>| x * 2).dedupe()
     ///     ); // outputs `SignalVec -> [2, 4, 6]`
     /// ```
     fn map_signal<S, F, M>(self, system: F) -> MapSignal<Self, S>
@@ -1254,16 +1263,16 @@ pub trait SignalVecExt: SignalVec {
             temp_handle.cleanup(world);
             let processor_entity = LazyEntity::new();
             let processor_logic = clone!((processor_entity) move |In(value): In<Item>, world: &mut World| {
-                if let Some(item_index_comp) = world.get::<ItemIndex>(processor_entity.get()) {
-                    let current_index = item_index_comp.0;
-                    if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<Item>>(*output_signal) {
-                        queue.0.push(VecDiff::UpdateAt {
-                            index: current_index,
-                            value,
-                        });
-                        process_signals(world, [output_signal], Box::new(()));
-                    }
-                }
+                let current_index = world.get::<ItemIndex>(*processor_entity).unwrap().0;
+                world
+                    .get_mut::<QueuedVecDiffs<Item>>(*output_signal)
+                    .unwrap()
+                    .0
+                    .push(VecDiff::UpdateAt {
+                        index: current_index,
+                        value,
+                    });
+                process_signals(world, [output_signal], Box::new(()));
             });
             let processor_handle = inner_signal.map(processor_logic).register(world);
             processor_entity.set(**processor_handle);
@@ -1274,16 +1283,13 @@ pub trait SignalVecExt: SignalVec {
         let signal = LazySignal::new(move |world: &mut World| {
             let factory_system_id = world.register_system(system);
             let output_signal_entity = LazyEntity::new();
-            let output_signal = *SignalBuilder::from_system::<Vec<VecDiff<S::Item>>, _, _, _>(
+            let output_signal = *signal::from_system::<Vec<VecDiff<S::Item>>, _, _, _>(
                 clone!((output_signal_entity) move |_: In<()>, world: &mut World| {
-                    if let Some(mut diffs) = world.get_mut::<QueuedVecDiffs<S::Item>>(output_signal_entity.get()) {
-                        if diffs.0.is_empty() {
-                            None
-                        } else {
-                            Some(diffs.0.drain(..).collect())
-                        }
-                    } else {
+                    let mut diffs = world.get_mut::<QueuedVecDiffs<S::Item>>(*output_signal_entity).unwrap();
+                    if diffs.0.is_empty() {
                         None
+                    } else {
+                        Some(diffs.0.drain(..).collect())
                     }
                 }),
             )
@@ -1465,9 +1471,11 @@ pub trait SignalVecExt: SignalVec {
                     }
                 }
                 if !new_diffs.is_empty() {
-                    if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<S::Item>>(*output_signal) {
-                        queue.0.extend(new_diffs);
-                    }
+                    world
+                        .get_mut::<QueuedVecDiffs<S::Item>>(*output_signal)
+                        .unwrap()
+                        .0
+                        .extend(new_diffs);
                     process_signals(world, [output_signal], Box::new(()));
                 }
             };
@@ -1502,7 +1510,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3, 4])
+    /// MutableVec::builder()
+    ///     .values([1, 2, 3, 4])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .filter(|In(x): In<i32>| x % 2 == 0); // outputs `SignalVec -> [2, 4]`
@@ -1543,7 +1552,7 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from(["1", "two", "NaN", "four", "5"])
+    /// MutableVec::builder().values(["1", "two", "NaN", "four", "5"])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .filter_map(|In(s): In<&'static str>| s.parse::<u32>().ok()); // outputs `SignalVec -> [1, 5]`
@@ -1588,11 +1597,11 @@ pub trait SignalVecExt: SignalVec {
     /// struct Even(bool);
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3, 4])
+    /// MutableVec::builder().values([1, 2, 3, 4])
     ///      .spawn(&mut world)
     ///      .signal_vec()
     ///      .filter_signal(|In(x): In<i32>| {
-    ///          SignalBuilder::from_resource().map_in(move |even: Even| x % 2 == if even.0 { 0 } else { 1 })
+    ///          signal::from_resource().map_in(move |even: Even| x % 2 == if even.0 { 0 } else { 1 })
     ///      }); // outputs `SignalVec -> [2, 4]` when `Even(true)` and `SignalVec -> [1, 3]` when `Even(false)`
     /// ```
     fn filter_signal<F, S, M>(self, system: F) -> FilterSignal<Self>
@@ -1640,20 +1649,15 @@ pub trait SignalVecExt: SignalVec {
             let processor_system = clone!((entity) move |In(filter): In<bool>, world: &mut World| {
                 let self_entity = *entity;
 
-                // The processor might run after its parent has been cleaned up.
-                let Ok(signal_index_comp) = world.query_filtered::<&FilterSignalIndex, Allow<Internal>>().get(world, self_entity) else {
-                    return;
-                };
-                let item_index = signal_index_comp.0;
-                let Ok(mut filter_signal_data) = world.query_filtered::<&mut FilterSignalData<T>, Allow<Internal>>().get_mut(world, parent) else {
-                    return;
-                };
-
-                // This item_index might be stale if other items were removed in the same frame.
-                // Ensure we don't panic.
-                if item_index >= filter_signal_data.items.len() {
-                    return;
-                }
+                let item_index = world
+                    .query_filtered::<&FilterSignalIndex, Allow<Internal>>()
+                    .get(world, self_entity)
+                    .unwrap()
+                    .0;
+                let mut filter_signal_data = world
+                    .query_filtered::<&mut FilterSignalData<T>, Allow<Internal>>()
+                    .get_mut(world, parent)
+                    .unwrap();
                 let old_filtered_state = filter_signal_data.items[item_index].filtered;
                 if old_filtered_state == filter {
                     // No change, do nothing.
@@ -1714,7 +1718,7 @@ pub trait SignalVecExt: SignalVec {
                         clone!(
                             (parent_entity) move |In(source_diffs): In<Vec<VecDiff<Self::Item>>>,
                             world: & mut World | {
-                                let parent = parent_entity.get();
+                                let parent =* parent_entity;
                                 let mut generated_diffs = vec![];
                                 for diff in source_diffs.into_iter() {
                                     match diff {
@@ -1790,10 +1794,7 @@ pub trait SignalVecExt: SignalVec {
                                                     );
                                                 if let Some(to_update) = signals_to_update {
                                                     for signal in to_update {
-                                                        if let Some(mut signal_index) =
-                                                            world.get_mut::<FilterSignalIndex>(**signal) {
-                                                            **signal_index += 1;
-                                                        }
+                                                        world.get_mut::<FilterSignalIndex>(**signal).unwrap().0 += 1;
                                                     }
                                                 }
                                                 if filtered {
@@ -1879,10 +1880,7 @@ pub trait SignalVecExt: SignalVec {
                                             signal.cleanup(world);
                                             if let Some(to_update) = signals_to_update {
                                                 for signal in to_update {
-                                                    if let Some(mut signal_index) =
-                                                        world.get_mut::<FilterSignalIndex>(**signal) {
-                                                        **signal_index -= 1;
-                                                    }
+                                                    world.get_mut::<FilterSignalIndex>(**signal).unwrap().0 -= 1;
                                                 }
                                             }
                                             if filtered {
@@ -1959,10 +1957,7 @@ pub trait SignalVecExt: SignalVec {
                                             // Now that the borrow from with_filter_signal_data is over, we can mutably access
                                             // world.
                                             for (i, signal) in items_to_update.into_iter().enumerate() {
-                                                if let Some(mut signal_index) =
-                                                    world.get_mut::<FilterSignalIndex>(**signal) {
-                                                    **signal_index = i;
-                                                }
+                                                world.get_mut::<FilterSignalIndex>(**signal).unwrap().0 = i;
                                             }
                                             if filtered {
                                                 generated_diffs.push(VecDiff::Move {
@@ -2040,7 +2035,7 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVecBuilder::from([1, 2, 5]).spawn(&mut world);
+    /// let mut vec = MutableVec::builder().values([1, 2, 5]).spawn(&mut world);
     /// let signal = vec.signal_vec().enumerate();
     /// // signal outputs `SignalVec -> [(Signal -> Some(0), 1), (Signal -> Some(1), 2), (Signal -> Some(2), 5)]`
     /// vec.write(&mut world).remove(1);
@@ -2063,7 +2058,7 @@ pub trait SignalVecExt: SignalVec {
             let processor_logic = clone!(
                 (processor_entity_handle) move |In(diffs): In<Vec<VecDiff<Self::Item>>>,
                 world: & mut World | {
-                    let processor_entity = processor_entity_handle.get();
+                    let processor_entity =* processor_entity_handle;
                     let mut state = world.get_mut::<EnumerateState>(processor_entity).unwrap();
                     let mut out_diffs = vec![];
 
@@ -2078,11 +2073,11 @@ pub trait SignalVecExt: SignalVec {
                     }
 
                     let create_index_signal = clone!((processor_entity_handle) move | key: usize | {
-                        SignalBuilder::from_system(
+                        signal::from_system(
                             clone!((processor_entity_handle) move |_: In<()>, query: Query<&EnumerateState, Allow<Internal>>| {
                                 Some(
                                     query
-                                        .get(processor_entity_handle.get())
+                                        .get(*processor_entity_handle)
                                         .ok()
                                         .and_then(|s| s.key_to_index.get(&key).copied()),
                                 )
@@ -2219,7 +2214,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3])
+    /// MutableVec::builder()
+    ///     .values([1, 2, 3])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .to_signal()
@@ -2275,7 +2271,7 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVecBuilder::from([1]).spawn(&mut world);
+    /// let mut vec = MutableVec::builder().values([1]).spawn(&mut world);
     /// let signal = vec.signal_vec().is_empty();
     /// // `signal` outputs `false`
     /// vec.write(&mut world).pop();
@@ -2301,7 +2297,7 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVecBuilder::from([1]).spawn(&mut world);
+    /// let mut vec = MutableVec::builder().values([1]).spawn(&mut world);
     /// let signal = vec.signal_vec().len();
     /// // `signal` outputs `1`
     /// vec.write(&mut world).pop();
@@ -2326,7 +2322,7 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVecBuilder::from([1, 2, 3]).spawn(&mut world);
+    /// let mut vec = MutableVec::builder().values([1, 2, 3]).spawn(&mut world);
     /// let signal = vec.signal_vec().sum();
     /// // `signal` outputs `6`
     /// vec.write(&mut world).push(4);
@@ -2355,11 +2351,13 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 3])
+    /// MutableVec::builder()
+    ///     .values([1, 3])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .chain(
-    ///         MutableVecBuilder::from([2, 4])
+    ///         MutableVec::builder()
+    ///             .values([2, 4])
     ///             .spawn(&mut world)
     ///             .signal_vec(),
     ///     ); // outputs `SignalVec -> [1, 3, 2, 4]`
@@ -2522,7 +2520,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3])
+    /// MutableVec::builder()
+    ///     .values([1, 2, 3])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .intersperse(0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
@@ -2662,7 +2661,7 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::signal::{Dedupe, Source};
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([1, 2, 3]).spawn(&mut world).signal_vec().intersperse_with(|_: In<Source<Option<usize>>>| 0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
+    /// MutableVec::builder().values([1, 2, 3]).spawn(&mut world).signal_vec().intersperse_with(|_: In<Source<Option<usize>>>| 0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
     /// ```
     fn intersperse_with<F, M>(self, separator_system: F) -> IntersperseWith<Self>
     where
@@ -2674,8 +2673,8 @@ pub trait SignalVecExt: SignalVec {
         struct IntersperseState<T> {
             /// The original, non-interspersed values. We need this to know the length.
             local_values: Vec<T>,
-            /// Stable keys for the separators. The key at index `i` corresponds to the separator that comes
-            /// _after_ `local_values[i]`.
+            /// Stable keys for the separators. The key at index `i` corresponds to the separator
+            /// that comes _after_ `local_values[i]`.
             separator_keys: Vec<usize>,
             /// Maps a separator's stable key to its current logical index (0, 1, 2...).
             key_to_index: HashMap<usize, usize>,
@@ -2704,13 +2703,13 @@ pub trait SignalVecExt: SignalVec {
             // 3. Define the helper to create an index signal for a given separator key. This signal reads from
             //    the central state component.
             let create_index_signal = clone!((state_entity_handle) move | key: usize | {
-                SignalBuilder::from_system(
+                signal::from_system(
                     clone!(
                         (state_entity_handle) move |_: In<()>,
                         query: Query<&IntersperseState<Self::Item>, Allow<Internal>>| {
                             Some(
                                 query
-                                    .get(state_entity_handle.get())
+                                    .get(*state_entity_handle)
                                     .ok()
                                     .and_then(|s| s.key_to_index.get(&key).copied()),
                             )
@@ -2723,7 +2722,7 @@ pub trait SignalVecExt: SignalVec {
             let processor_logic = clone!(
                 (state_entity_handle, create_index_signal) move |In(diffs): In<Vec<VecDiff<Self::Item>>>,
                 world: & mut World | {
-                    let state_entity = state_entity_handle.get();
+                    let state_entity =* state_entity_handle;
                     let mut out_diffs = Vec::new();
                     for diff in diffs {
                         match diff {
@@ -2987,7 +2986,7 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([3, 2, 1]).spawn(&mut world).signal_vec().sort_by(|In((left, right)): In<(i32, i32)>| left.cmp(&right)); // outputs `SignalVec -> [1, 2, 3]`
+    /// MutableVec::builder().values([3, 2, 1]).spawn(&mut world).signal_vec().sort_by(|In((left, right)): In<(i32, i32)>| left.cmp(&right)); // outputs `SignalVec -> [1, 2, 3]`
     /// ```
     fn sort_by<F, M>(self, compare_system: F) -> SortBy<Self>
     where
@@ -3170,7 +3169,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([3, 2, 1])
+    /// MutableVec::builder()
+    ///     .values([3, 2, 1])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .sort_by_cmp(); // outputs `SignalVec -> [1, 2, 3]`
@@ -3194,7 +3194,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// MutableVecBuilder::from([3, 2, 1])
+    /// MutableVec::builder()
+    ///     .values([3, 2, 1])
     ///     .spawn(&mut world)
     ///     .signal_vec()
     ///     .sort_by_key(|In(x): In<i32>| -x); // outputs `SignalVec -> [1, 2, 3]`
@@ -3386,13 +3387,12 @@ pub trait SignalVecExt: SignalVec {
     ///
     /// let mut world = World::new();
     ///
-    /// let inner1 = MutableVecBuilder::from([1, 2]).spawn(&mut world);
-    /// let inner2 = MutableVecBuilder::from([3, 4, 5]).spawn(&mut world);
+    /// let inner1 = MutableVec::builder().values([1, 2]).spawn(&mut world);
+    /// let inner2 = MutableVec::builder().values([3, 4, 5]).spawn(&mut world);
     ///
-    /// let outer = MutableVecBuilder::from([
-    ///     inner1.signal_vec(),
-    ///     inner2.signal_vec(),
-    /// ]).spawn(&mut world);
+    /// let outer = MutableVec::builder()
+    ///     .values([inner1.signal_vec(), inner2.signal_vec()])
+    ///     .spawn(&mut world);
     ///
     /// let flattened = outer.signal_vec().flatten();
     /// // flattened outputs `[1, 2, 3, 4, 5]`
@@ -3419,16 +3419,13 @@ pub trait SignalVecExt: SignalVec {
             let output_signal_entity = LazyEntity::new();
 
             // The output signal just drains and emits any queued diffs
-            let output_signal = *SignalBuilder::from_system::<Vec<VecDiff<InnerItem<Self>>>, _, _, _>(
+            let output_signal = *signal::from_system::<Vec<VecDiff<InnerItem<Self>>>, _, _, _>(
                 clone!((output_signal_entity) move |_: In<()>, world: &mut World| {
-                    if let Some(mut diffs) = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(output_signal_entity.get()) {
-                        if diffs.0.is_empty() {
-                            None
-                        } else {
-                            Some(diffs.0.drain(..).collect())
-                        }
-                    } else {
+                    let mut diffs = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal_entity).unwrap();
+                    if diffs.0.is_empty() {
                         None
+                    } else {
+                        Some(diffs.0.drain(..).collect())
                     }
                 }),
             )
@@ -3461,9 +3458,10 @@ pub trait SignalVecExt: SignalVec {
                 }
             }
 
-            /// Creates a processor for an inner SignalVec that translates its diffs to the flattened output.
-            /// Returns (processor handle, replay triggers to call later).
-            /// NOTE: The caller should add the entry to FlattenState.items and THEN call trigger_replays.
+            /// Creates a processor for an inner SignalVec that translates its diffs to the
+            /// flattened output. Returns (processor handle, replay triggers to call
+            /// later). NOTE: The caller should add the entry to FlattenState.items and
+            /// THEN call trigger_replays.
             fn create_inner_processor<O: Clone + SSs>(
                 world: &mut World,
                 output_signal: SignalSystem,
@@ -3474,23 +3472,13 @@ pub trait SignalVecExt: SignalVec {
 
                 // Processor that handles diffs from the inner SignalVec
                 let processor_logic = clone!((processor_entity) move |In(diffs): In<Vec<VecDiff<O>>>, world: &mut World| {
-                    let self_entity = processor_entity.get();
+                    let self_entity =* processor_entity;
 
                     // Get our current index
-                    let Some(item_index_comp) = world.get::<FlattenItemIndex>(self_entity) else {
-                        return;
-                    };
-                    let item_index = item_index_comp.0;
+                    let item_index = world.get::<FlattenItemIndex>(self_entity).unwrap().0;
 
                     // Get the flatten state
-                    let Some(mut state) = world.get_mut::<FlattenState>(*output_signal) else {
-                        return;
-                    };
-
-                    // Bounds check (should not happen if used correctly, but defensive)
-                    if item_index >= state.items.len() {
-                        return;
-                    }
+                    let mut state = world.get_mut::<FlattenState>(*output_signal).unwrap();
 
                     // Calculate offset (sum of lengths of all inner vecs before this one)
                     let offset: usize = state.items[..item_index]
@@ -3572,9 +3560,11 @@ pub trait SignalVecExt: SignalVec {
 
                     // Queue the translated diffs
                     if !out_diffs.is_empty() {
-                        if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<O>>(*output_signal) {
-                            queue.0.extend(out_diffs);
-                        }
+                        world
+                            .get_mut::<QueuedVecDiffs<O>>(*output_signal)
+                            .unwrap()
+                            .0
+                            .extend(out_diffs);
                         process_signals(world, [output_signal], Box::new(()));
                     }
                 });
@@ -3592,7 +3582,7 @@ pub trait SignalVecExt: SignalVec {
 
             // Main manager that handles outer SignalVec diffs
             let manager_logic = clone!((output_signal_entity) move |In(diffs): In<Vec<VecDiff<Self::Item>>>, world: &mut World| {
-                let output_signal: SignalSystem = output_signal_entity.get().into();
+                let output_signal: SignalSystem = (*output_signal_entity).into();
                 let mut out_diffs: Vec<VecDiff<InnerItem<Self>>> = Vec::new();
 
                 for diff in diffs {
@@ -3611,9 +3601,11 @@ pub trait SignalVecExt: SignalVec {
                             // Note: The inner processors will emit InsertAt diffs for their initial values,
                             // so we need Clear to come BEFORE those. We'll queue it directly now.
                             if had_old_items {
-                                if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal) {
-                                    queue.0.push(VecDiff::Clear);
-                                }
+                                world
+                                    .get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal)
+                                    .unwrap()
+                                    .0
+                                    .push(VecDiff::Clear);
                             }
 
                             // Create processors and collect their replay triggers
@@ -3641,9 +3633,7 @@ pub trait SignalVecExt: SignalVec {
                                         .collect()
                                 };
                                 for (handle_entity, new_index) in handles_to_update {
-                                    if let Some(mut idx) = world.get_mut::<FlattenItemIndex>(*handle_entity) {
-                                        idx.0 = new_index;
-                                    }
+                                    world.get_mut::<FlattenItemIndex>(*handle_entity).unwrap().0 = new_index;
                                 }
                             }
 
@@ -3676,9 +3666,11 @@ pub trait SignalVecExt: SignalVec {
                                 for _ in 0..old_len {
                                     remove_diffs.push(VecDiff::RemoveAt { index: offset });
                                 }
-                                if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal) {
-                                    queue.0.extend(remove_diffs);
-                                }
+                                world
+                                    .get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal)
+                                    .unwrap()
+                                    .0
+                                    .extend(remove_diffs);
                             }
 
                             // Create new processor
@@ -3714,9 +3706,7 @@ pub trait SignalVecExt: SignalVec {
                                         .collect()
                                 };
                                 for (handle_entity, new_index) in handles_to_update {
-                                    if let Some(mut idx) = world.get_mut::<FlattenItemIndex>(*handle_entity) {
-                                        idx.0 = new_index;
-                                    }
+                                    world.get_mut::<FlattenItemIndex>(*handle_entity).unwrap().0 = new_index;
                                 }
                             }
 
@@ -3749,9 +3739,7 @@ pub trait SignalVecExt: SignalVec {
                                         .collect()
                                 };
                                 for (handle_entity, new_idx) in handles_to_update {
-                                    if let Some(mut idx) = world.get_mut::<FlattenItemIndex>(*handle_entity) {
-                                        idx.0 = new_idx;
-                                    }
+                                    world.get_mut::<FlattenItemIndex>(*handle_entity).unwrap().0 = new_idx;
                                 }
                             }
 
@@ -3833,9 +3821,11 @@ pub trait SignalVecExt: SignalVec {
 
                 // Queue the diffs
                 if !out_diffs.is_empty() {
-                    if let Some(mut queue) = world.get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal) {
-                        queue.0.extend(out_diffs);
-                    }
+                    world
+                        .get_mut::<QueuedVecDiffs<InnerItem<Self>>>(*output_signal)
+                        .unwrap()
+                        .0
+                        .extend(out_diffs);
                     process_signals(world, [output_signal], Box::new(()));
                 }
             });
@@ -3873,7 +3863,7 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVecBuilder::from([1, 2, 3]).spawn(&mut world);
+    /// let mut vec = MutableVec::builder().values([1, 2, 3]).spawn(&mut world);
     /// let signal = vec.signal_vec().debug();
     /// // signal logs `[ Replace { values: [ 1, 2, 3 ] } ]`
     /// vec.write(&mut world).push(4);
@@ -3905,13 +3895,15 @@ pub trait SignalVecExt: SignalVec {
     /// let mut world = World::new();
     /// let condition = true;
     /// let signal = if condition {
-    ///     MutableVecBuilder::from([1, 2, 3])
+    ///     MutableVec::builder()
+    ///         .values([1, 2, 3])
     ///         .spawn(&mut world)
     ///         .signal_vec()
     ///         .map_in(|x: i32| x * 2)
     ///         .boxed() // this is a `Map<Source<i32>>`
     /// } else {
-    ///     MutableVecBuilder::from([1, 2, 3])
+    ///     MutableVec::builder()
+    ///         .values([1, 2, 3])
     ///         .spawn(&mut world)
     ///         .signal_vec()
     ///         .filter(|In(x): In<i32>| x % 2 == 0)
@@ -3935,16 +3927,18 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system(|_: In<()>| true).switch_signal_vec(
+    /// signal::from_system(|_: In<()>| true).switch_signal_vec(
     ///     |In(condition): In<bool>, world: &mut World| {
     ///         if condition {
-    ///             MutableVecBuilder::from([1, 2, 3])
+    ///             MutableVec::builder()
+    ///                 .values([1, 2, 3])
     ///                 .spawn(world)
     ///                 .signal_vec()
     ///                 .map_in(|x: i32| x * 2)
     ///                 .boxed_clone() // this is a `Map<Source<i32>>`
     ///         } else {
-    ///             MutableVecBuilder::from([1, 2, 3])
+    ///             MutableVec::builder()
+    ///                 .values([1, 2, 3])
     ///                 .spawn(world)
     ///                 .signal_vec()
     ///                 .filter(|In(x): In<i32>| x % 2 == 0)
@@ -4121,7 +4115,7 @@ pub struct MutableVec<T> {
 
 impl<T> Clone for MutableVec<T> {
     fn clone(&self) -> Self {
-        self.references.fetch_add(1, AtomicOrdering::SeqCst);
+        self.references.fetch_add(1, atomic::Ordering::Relaxed);
         Self {
             entity: self.entity,
             references: self.references.clone(),
@@ -4132,13 +4126,35 @@ impl<T> Clone for MutableVec<T> {
 
 impl<T> Drop for MutableVec<T> {
     fn drop(&mut self) {
-        if self.references.fetch_sub(1, AtomicOrdering::SeqCst) == 1 {
+        if self.references.fetch_sub(1, atomic::Ordering::Relaxed) == 1 {
             STALE_MUTABLE_VECS.lock().unwrap().push(self.entity);
         }
     }
 }
 
 impl<T> MutableVec<T> {
+    /// Creates a [`Builder`] for constructing a [`MutableVec`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// let mut world = World::new();
+    /// // Empty MutableVec
+    /// let vec = MutableVec::<i32>::builder().spawn(&mut world);
+    /// // With initial values
+    /// let vec = MutableVec::builder().values([1, 2, 3]).spawn(&mut world);
+    /// // With custom initialization
+    /// let vec = MutableVec::builder()
+    ///     .with_values(|v| v.extend(0..10))
+    ///     .spawn(&mut world);
+    /// ```
+    pub fn builder() -> Builder<T> {
+        Builder::new()
+    }
+
     /// Provides read-only access to the underlying [`Vec`] via either a `&World` or a
     /// `&Query<MutableVecData<T>>`.
     pub fn read<'s>(&self, mutable_vec_data_reader: impl ReadMutableVecData<'s, T>) -> MutableVecReadGuard<'s, T>
@@ -4175,15 +4191,12 @@ impl<T> MutableVec<T> {
                 if replay_onces.contains(*replay_entity) {
                     let first_replay = !core::mem::replace(&mut *has_replayed, true);
                     if first_replay && was_initially_empty {
-                        // Initial replay with empty vec - just forward upstream diffs
                         if upstream_diffs.is_empty() {
                             None
                         } else {
                             Some(upstream_diffs)
                         }
                     } else {
-                        // Either non-empty initial state, or subsequent replay (e.g., switch_signal_vec)
-                        // Always emit Replace with current state
                         let current_vec = self_.read(&mutable_vec_datas).to_vec();
                         if current_vec.is_empty() {
                             None
@@ -4273,11 +4286,70 @@ where
     }
 }
 
-/// Builder for constructing a [`MutableVec`] with initial values, e.g. `MutableVecBuilder::from([0,
-/// 1, 2]).spawn(&mut World)`.
-pub struct MutableVecBuilder<T>(Vec<T>);
+/// Builder for constructing a [`MutableVec`].
+///
+/// # Example
+///
+/// ```
+/// use bevy_ecs::prelude::*;
+/// use jonmo::prelude::*;
+///
+/// let mut world = World::new();
+/// let vec = MutableVec::builder().values([1, 2, 3]).spawn(&mut world);
+/// ```
+pub struct Builder<T>(Vec<T>);
+
+impl<T> Default for Builder<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> Builder<T> {
+    /// Creates a new empty builder.
+    pub fn new() -> Self {
+        Self(Vec::new())
+    }
+
+    /// Sets the initial values of the [`MutableVec`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// let mut world = World::new();
+    /// let vec = MutableVec::builder().values([1, 2, 3]).spawn(&mut world);
+    /// ```
+    pub fn values(mut self, values: impl Into<Vec<T>>) -> Self {
+        self.0 = values.into();
+        self
+    }
 
-impl<T, A> From<A> for MutableVecBuilder<T>
+    /// Mutably access the inner [`Vec`] for custom initialization.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// let mut world = World::new();
+    /// let vec = MutableVec::builder()
+    ///     .with_values(|v| {
+    ///         v.extend(0..10);
+    ///         v.push(100);
+    ///     })
+    ///     .spawn(&mut world);
+    /// ```
+    pub fn with_values(mut self, f: impl FnOnce(&mut Vec<T>)) -> Self {
+        f(&mut self.0);
+        self
+    }
+}
+
+impl<T, A> From<A> for Builder<T>
 where
     Vec<T>: From<A>,
 {
@@ -4286,7 +4358,7 @@ where
     }
 }
 
-impl<T: SSs + Clone> MutableVecBuilder<T> {
+impl<T: SSs + Clone> Builder<T> {
     /// Spawns a [`MutableVec`] using a `&mut World`.
     pub fn spawn(self, world: &mut World) -> MutableVec<T> {
         let (data, data_entity) = new_mutable_vec_data::<T>(self.0);
@@ -4556,7 +4628,9 @@ pub(crate) mod tests {
 
             // The output of our `for_each` system will be the full, reconstructed vector.
             app.init_resource::<FinalSignalOutput<Vec<String>>>();
-            let source_vec = MutableVecBuilder::from(["a".to_string(), "b".to_string()]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder()
+                .values(["a".to_string(), "b".to_string()])
+                .spawn(app.world_mut());
 
             // This system reconstructs the state of the vec by applying the diffs it
             // receives. It then outputs the complete, current state. This allows us to
@@ -4686,7 +4760,7 @@ pub(crate) mod tests {
             app.init_resource::<SignalVecOutput<i32>>();
 
             // Start with a vec containing initial values
-            let source_vec = MutableVecBuilder::from([1, 2, 3]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([1, 2, 3]).spawn(app.world_mut());
 
             // Create a signal_vec and register it
             let signal = source_vec.signal_vec();
@@ -4730,7 +4804,7 @@ pub(crate) mod tests {
             app.init_resource::<SignalVecOutput<String>>();
 
             // The source vector that we will mutate.
-            let source_vec = MutableVecBuilder::from([1, 10]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([1, 10]).spawn(app.world_mut());
 
             // Define a resource that the mapping system will depend on. This allows us to
             // test system failure by removing the resource.
@@ -4937,7 +5011,7 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<String>>();
 
-            let source_vec = MutableVecBuilder::from([1, 10, 100]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([1, 10, 100]).spawn(app.world_mut());
 
             // A variable to be captured by the `map_in` closure.
             // We'll use this to demonstrate that the closure's captured state is respected
@@ -5130,7 +5204,7 @@ pub(crate) mod tests {
             app.init_resource::<SignalVecOutput<String>>();
 
             // The source vector contains integers.
-            let source_vec = MutableVecBuilder::from([10, 20]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([10, 20]).spawn(app.world_mut());
 
             // The signal chain under test, using `map_in_ref` with a function pointer
             // that operates on a reference (`&i32`). This is an idiomatic use case.
@@ -5298,11 +5372,13 @@ pub(crate) mod tests {
 
             // The source vec contains entities. The goal is to create a derived vec that
             // contains the _names_ of these entities.
-            let entity_vec = MutableVecBuilder::from([entity_a, entity_b]).spawn(app.world_mut());
+            let entity_vec = MutableVec::builder()
+                .values([entity_a, entity_b])
+                .spawn(app.world_mut());
 
             // This "factory" system takes an entity and creates a signal that tracks its
             // `Name`.
-            let factory_system = |In(entity): In<Entity>| SignalBuilder::from_component::<Name>(entity).dedupe();
+            let factory_system = |In(entity): In<Entity>| signal::from_component::<Name>(entity).dedupe();
 
             // Apply `map_signal` to transform the SignalVec`<Entity>` into a
             // SignalVec`<Name>`.
@@ -5483,7 +5559,7 @@ pub(crate) mod tests {
             app.init_resource::<SignalVecOutput<i32>>();
 
             // The source vector contains a mix of values to be filtered.
-            let source_vec = MutableVecBuilder::from([1, 2, 3, 4]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([1, 2, 3, 4]).spawn(app.world_mut());
 
             // The filter predicate: only allow even numbers.
             let is_even = |In(x): In<i32>| x % 2 == 0;
@@ -5614,7 +5690,9 @@ pub(crate) mod tests {
             app.init_resource::<SignalVecOutput<u32>>();
 
             // The source vector contains strings, some of which are parsable as numbers.
-            let source_vec = MutableVecBuilder::from(["10", "foo", "20", "bar"]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder()
+                .values(["10", "foo", "20", "bar"])
+                .spawn(app.world_mut());
 
             // The filter_map predicate: parse strings to u32, returning Some on success
             // and None on failure.
@@ -5760,9 +5838,9 @@ pub(crate) mod tests {
 
             // --- Setup --- Initially, filter for even numbers.
             app.insert_resource(FilterMode(true));
-            let source_vec = MutableVecBuilder::from([1, 2, 3, 4]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([1, 2, 3, 4]).spawn(app.world_mut());
             let filtered_signal = source_vec.signal_vec().filter_signal(|In(val): In<i32>| {
-                SignalBuilder::from_resource::<FilterMode>().map(move |In(mode): In<FilterMode>| {
+                signal::from_resource::<FilterMode>().map(move |In(mode): In<FilterMode>| {
                     // even or odd
                     if mode.0 { val % 2 == 0 } else { val % 2 != 0 }
                 })
@@ -5893,19 +5971,19 @@ pub(crate) mod tests {
             app.insert_resource(IsEven(true));
 
             // The source vector
-            let source_vec = MutableVecBuilder::from([-2, -1, 0, 1, 2]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([-2, -1, 0, 1, 2]).spawn(app.world_mut());
 
             // --- The Signal Chain ---
             let final_signal = source_vec
                 .signal_vec()
                 // Filter 1: controlled by IsPositive resource.
                 .filter_signal(|In(val): In<i32>| {
-                    SignalBuilder::from_resource::<IsPositive>()
+                    signal::from_resource::<IsPositive>()
                         .map(move |In(res): In<IsPositive>| if res.0 { val > 0 } else { val <= 0 })
                 })
                 // Filter 2: controlled by IsEven resource.
                 .filter_signal(|In(val): In<i32>| {
-                    SignalBuilder::from_resource::<IsEven>()
+                    signal::from_resource::<IsEven>()
                         .map(move |In(res): In<IsEven>| if res.0 { val % 2 == 0 } else { val % 2 != 0 })
                 });
             let handle = final_signal
@@ -5979,7 +6057,9 @@ pub(crate) mod tests {
             // --- 1. Setup ---
             let mut app = create_test_app();
             app.init_resource::<FinalSignalOutput<Vec<String>>>();
-            let source_vec = MutableVecBuilder::from(["a".to_string(), "b".to_string()]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder()
+                .values(["a".to_string(), "b".to_string()])
+                .spawn(app.world_mut());
 
             // The signal chain under test.
             let state_signal = source_vec.signal_vec().to_signal();
@@ -6098,7 +6178,9 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<FinalSignalOutput<bool>>();
             // Start with a non-empty vec to test the `false` state first.
-            let source_vec = MutableVecBuilder::from(["a".to_string(), "b".to_string()]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder()
+                .values(["a".to_string(), "b".to_string()])
+                .spawn(app.world_mut());
 
             let is_empty_signal = source_vec.signal_vec().is_empty();
             let handle = is_empty_signal
@@ -6217,7 +6299,9 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<FinalSignalOutput<usize>>();
             // Start with a non-empty vec.
-            let source_vec = MutableVecBuilder::from(["a".to_string(), "b".to_string()]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder()
+                .values(["a".to_string(), "b".to_string()])
+                .spawn(app.world_mut());
 
             let len_signal = source_vec.signal_vec().len();
             let handle = len_signal.map(capture_final_output::<usize>).register(app.world_mut());
@@ -6345,7 +6429,7 @@ pub(crate) mod tests {
             // --- 1. Setup ---
             let mut app = create_test_app();
             app.init_resource::<FinalSignalOutput<i32>>();
-            let source_vec = MutableVecBuilder::from([10, 20]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([10, 20]).spawn(app.world_mut());
 
             let sum_signal = source_vec.signal_vec().sum();
             let handle = sum_signal.map(capture_final_output::<i32>).register(app.world_mut());
@@ -6461,8 +6545,12 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<String>>();
 
-            let left_vec = MutableVecBuilder::from(["L1".to_string(), "L2".to_string()]).spawn(app.world_mut());
-            let right_vec = MutableVecBuilder::from(["R1".to_string(), "R2".to_string()]).spawn(app.world_mut());
+            let left_vec = MutableVec::builder()
+                .values(["L1".to_string(), "L2".to_string()])
+                .spawn(app.world_mut());
+            let right_vec = MutableVec::builder()
+                .values(["R1".to_string(), "R2".to_string()])
+                .spawn(app.world_mut());
 
             let chained_signal = left_vec.signal_vec().chain(right_vec.signal_vec());
             let handle = chained_signal
@@ -7020,7 +7108,7 @@ pub(crate) mod tests {
             // Use `insert_resource` with an explicit value, as `ItemOrSep` doesn't have a Default.
             app.insert_resource(SignalVecOutput::<ItemOrSep>(Vec::new()));
 
-            let source_vec = MutableVecBuilder::from([10u32, 20, 30]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([10u32, 20, 30]).spawn(app.world_mut());
 
             // CORRECTION: The closure's input parameter must be the concrete type
             // `signal::Source<Option<usize>>`, not a generic `impl Signal`. This satisfies
@@ -7046,7 +7134,7 @@ pub(crate) mod tests {
 
             // CORRECTION: Use the correct `signal::Source` for the placeholder.
             // We also need to provide the type hint for the closure to resolve ambiguity.
-            let placeholder_sep = ItemOrSep::Sep(SignalBuilder::from_system(|_: In<()>| None::<usize>));
+            let placeholder_sep = ItemOrSep::Sep(signal::from_system(|_: In<()>| None::<usize>));
             assert_eq!(
                 current_state,
                 vec![
@@ -7162,7 +7250,9 @@ pub(crate) mod tests {
             // --- 1. Setup ---
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<(u32, char)>>();
-            let source_vec = MutableVecBuilder::from([(3, 'c'), (1, 'a'), (4, 'd')]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder()
+                .values([(3, 'c'), (1, 'a'), (4, 'd')])
+                .spawn(app.world_mut());
             let compare_system = |In((left, right)): In<((u32, char), (u32, char))>| left.0.cmp(&right.0);
             let sorted_signal = source_vec.signal_vec().sort_by(compare_system);
             let handle = sorted_signal
@@ -7287,7 +7377,7 @@ pub(crate) mod tests {
             app.init_resource::<SignalVecOutput<i32>>();
 
             // The source vector, intentionally unsorted.
-            let source_vec = MutableVecBuilder::from([5, 1, 4, -2, 3]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([5, 1, 4, -2, 3]).spawn(app.world_mut());
 
             // The signal chain under test, using the convenience method.
             let sorted_signal = source_vec.signal_vec().sort_by_cmp();
@@ -7374,12 +7464,13 @@ pub(crate) mod tests {
 
             app.init_resource::<SignalVecOutput<DataItem>>();
 
-            let source_vec = MutableVecBuilder::from([
-                DataItem { id: 3, name: "C" },
-                DataItem { id: 1, name: "A" },
-                DataItem { id: 4, name: "D" },
-            ])
-            .spawn(app.world_mut());
+            let source_vec = MutableVec::builder()
+                .values([
+                    DataItem { id: 3, name: "C" },
+                    DataItem { id: 1, name: "A" },
+                    DataItem { id: 4, name: "D" },
+                ])
+                .spawn(app.world_mut());
 
             let key_system = |In(item): In<DataItem>| item.id;
             let sorted_signal = source_vec.signal_vec().sort_by_key(key_system);
@@ -7517,7 +7608,7 @@ pub(crate) mod tests {
 
             app.init_resource::<EnumOutput>();
 
-            let source_vec = MutableVecBuilder::from([10, 20, 30]).spawn(app.world_mut());
+            let source_vec = MutableVec::builder().values([10, 20, 30]).spawn(app.world_mut());
 
             let enumerated = source_vec.signal_vec().enumerate();
 
@@ -7769,18 +7860,15 @@ pub(crate) mod tests {
 
             // --- Setup ---
             // Create the inner vectors that will be the items of our outer vector.
-            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
-            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
-            let vec_c = MutableVecBuilder::<u32>::from([]).spawn(app.world_mut()); // Start with an empty inner vec
+            let vec_a = MutableVec::builder().values([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVec::builder().values([20u32]).spawn(app.world_mut());
+            let vec_c = MutableVec::<u32>::builder().spawn(app.world_mut()); // Start with an empty inner vec
 
             // Create the outer vector, which holds SignalVecs.
             // No need for boxed_clone() since all inner vecs are the same concrete type (Source<u32>)
-            let source_of_vecs = MutableVecBuilder::from([
-                vec_a.signal_vec(),
-                vec_b.signal_vec(),
-                vec_c.signal_vec(),
-            ])
-            .spawn(app.world_mut());
+            let source_of_vecs = MutableVec::builder()
+                .values([vec_a.signal_vec(), vec_b.signal_vec(), vec_c.signal_vec()])
+                .spawn(app.world_mut());
 
             // The signal chain under test.
             let flattened_signal = source_of_vecs.signal_vec().flatten();
@@ -7877,11 +7965,7 @@ pub(crate) mod tests {
             assert_eq!(diffs.len(), 1, "Removing vec_b should produce 1 diff.");
             apply_diffs(&mut current_state, diffs);
             // The final state should no longer contain 20.
-            assert_eq!(
-                current_state,
-                vec![111, 12],
-                "State after removing vec_b is incorrect."
-            );
+            assert_eq!(current_state, vec![111, 12], "State after removing vec_b is incorrect.");
             // Note: vec_c is now at index 1 in the outer vec.
 
             // --- 8. Cleanup Verification ---
@@ -7892,7 +7976,7 @@ pub(crate) mod tests {
             assert!(diffs.is_empty(), "Should ignore diffs from the removed vec_b.");
 
             // --- 9. Outer Vec Change: Push a new vector ---
-            let vec_d = MutableVecBuilder::from([40u32, 41]).spawn(app.world_mut());
+            let vec_d = MutableVec::builder().values([40u32, 41]).spawn(app.world_mut());
             source_of_vecs.write(app.world_mut()).push(vec_d.signal_vec());
             app.update();
 
@@ -7938,7 +8022,7 @@ pub(crate) mod tests {
             );
 
             // --- 12. Outer Vec Change: UpdateAt (replace vec_c with a new vec) ---
-            let vec_e = MutableVecBuilder::from([50u32, 51, 52]).spawn(app.world_mut());
+            let vec_e = MutableVec::builder().values([50u32, 51, 52]).spawn(app.world_mut());
             source_of_vecs.write(app.world_mut()).set(2, vec_e.signal_vec()); // Replace vec_c
             app.update();
 
@@ -7975,12 +8059,11 @@ pub(crate) mod tests {
             assert!(current_state.is_empty(), "Final state should be empty after clear.");
 
             // --- 15. Outer Vec Change: Replace (re-populate after clear) ---
-            let vec_f = MutableVecBuilder::from([60u32]).spawn(app.world_mut());
-            let vec_g = MutableVecBuilder::from([70u32, 71]).spawn(app.world_mut());
-            source_of_vecs.write(app.world_mut()).replace(vec![
-                vec_f.signal_vec(),
-                vec_g.signal_vec(),
-            ]);
+            let vec_f = MutableVec::builder().values([60u32]).spawn(app.world_mut());
+            let vec_g = MutableVec::builder().values([70u32, 71]).spawn(app.world_mut());
+            source_of_vecs
+                .write(app.world_mut())
+                .replace(vec![vec_f.signal_vec(), vec_g.signal_vec()]);
             app.update();
 
             let diffs = get_and_clear_output::<u32>(app.world_mut());
@@ -8040,14 +8123,12 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<u32>>();
 
-            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
-            let vec_b = MutableVecBuilder::from([30u32, 31]).spawn(app.world_mut());
+            let vec_a = MutableVec::builder().values([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVec::builder().values([30u32, 31]).spawn(app.world_mut());
 
-            let source = MutableVecBuilder::from([
-                vec_a.signal_vec(),
-                vec_b.signal_vec(),
-            ])
-            .spawn(app.world_mut());
+            let source = MutableVec::builder()
+                .values([vec_a.signal_vec(), vec_b.signal_vec()])
+                .spawn(app.world_mut());
 
             let handle = source
                 .signal_vec()
@@ -8062,7 +8143,7 @@ pub(crate) mod tests {
             assert_eq!(current_state, vec![10, 11, 30, 31], "Initial state");
 
             // Insert a new inner vec in the middle
-            let vec_mid = MutableVecBuilder::from([20u32, 21, 22]).spawn(app.world_mut());
+            let vec_mid = MutableVec::builder().values([20u32, 21, 22]).spawn(app.world_mut());
             source.write(app.world_mut()).insert(1, vec_mid.signal_vec());
             app.update();
 
@@ -8104,14 +8185,12 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<u32>>();
 
-            let vec_a = MutableVecBuilder::from([10u32]).spawn(app.world_mut());
-            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
+            let vec_a = MutableVec::builder().values([10u32]).spawn(app.world_mut());
+            let vec_b = MutableVec::builder().values([20u32]).spawn(app.world_mut());
 
-            let source = MutableVecBuilder::from([
-                vec_a.signal_vec(),
-                vec_b.signal_vec(),
-            ])
-            .spawn(app.world_mut());
+            let source = MutableVec::builder()
+                .values([vec_a.signal_vec(), vec_b.signal_vec()])
+                .spawn(app.world_mut());
 
             let handle = source
                 .signal_vec()
@@ -8148,7 +8227,7 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<u32>>();
 
-            let source = MutableVecBuilder::<Source<u32>>::from([]).spawn(app.world_mut());
+            let source = MutableVec::<Source<u32>>::builder().spawn(app.world_mut());
 
             let handle = source
                 .signal_vec()
@@ -8163,7 +8242,7 @@ pub(crate) mod tests {
             assert!(current_state.is_empty(), "Initial state should be empty");
 
             // Push first inner vec
-            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
+            let vec_a = MutableVec::builder().values([10u32, 11]).spawn(app.world_mut());
             source.write(app.world_mut()).push(vec_a.signal_vec());
             app.update();
 
@@ -8172,7 +8251,7 @@ pub(crate) mod tests {
             assert_eq!(current_state, vec![10, 11], "Push to empty outer vec");
 
             // Push second inner vec
-            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
+            let vec_b = MutableVec::builder().values([20u32]).spawn(app.world_mut());
             source.write(app.world_mut()).push(vec_b.signal_vec());
             app.update();
 
@@ -8183,21 +8262,59 @@ pub(crate) mod tests {
             handle.cleanup(app.world_mut());
         }
 
+        {
+            // --- 21b. Replace outer vec with empty (should emit Clear) ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
+
+            let vec_a = MutableVec::builder().values([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVec::builder().values([20u32]).spawn(app.world_mut());
+
+            let source = MutableVec::builder()
+                .values([vec_a.signal_vec(), vec_b.signal_vec()])
+                .spawn(app.world_mut());
+
+            let handle = source
+                .signal_vec()
+                .flatten()
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            // Initial state should populate
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            let mut current_state: Vec<u32> = vec![];
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 11, 20], "Initial state");
+
+            // Replace with empty outer vec should emit Clear
+            source.write(app.world_mut()).replace(Vec::<Source<u32>>::new());
+            app.update();
+
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Replace to empty should produce one diff.");
+            assert!(matches!(diffs[0], VecDiff::Clear), "Expected Clear diff.");
+            apply_diffs(&mut current_state, diffs);
+            assert!(
+                current_state.is_empty(),
+                "State should be empty after Replace to empty."
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
         {
             // --- 22. Move forward on outer vec (index 0 -> 2) ---
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<u32>>();
 
-            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
-            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
-            let vec_c = MutableVecBuilder::from([30u32, 31, 32]).spawn(app.world_mut());
+            let vec_a = MutableVec::builder().values([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVec::builder().values([20u32]).spawn(app.world_mut());
+            let vec_c = MutableVec::builder().values([30u32, 31, 32]).spawn(app.world_mut());
 
-            let source = MutableVecBuilder::from([
-                vec_a.signal_vec(),
-                vec_b.signal_vec(),
-                vec_c.signal_vec(),
-            ])
-            .spawn(app.world_mut());
+            let source = MutableVec::builder()
+                .values([vec_a.signal_vec(), vec_b.signal_vec(), vec_c.signal_vec()])
+                .spawn(app.world_mut());
 
             let handle = source
                 .signal_vec()
@@ -8242,16 +8359,13 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<u32>>();
 
-            let vec_a = MutableVecBuilder::from([10u32]).spawn(app.world_mut());
-            let vec_empty = MutableVecBuilder::<u32>::from([]).spawn(app.world_mut());
-            let vec_c = MutableVecBuilder::from([30u32]).spawn(app.world_mut());
+            let vec_a = MutableVec::builder().values([10u32]).spawn(app.world_mut());
+            let vec_empty = MutableVec::<u32>::builder().spawn(app.world_mut());
+            let vec_c = MutableVec::builder().values([30u32]).spawn(app.world_mut());
 
-            let source = MutableVecBuilder::from([
-                vec_a.signal_vec(),
-                vec_empty.signal_vec(),
-                vec_c.signal_vec(),
-            ])
-            .spawn(app.world_mut());
+            let source = MutableVec::builder()
+                .values([vec_a.signal_vec(), vec_empty.signal_vec(), vec_c.signal_vec()])
+                .spawn(app.world_mut());
 
             let handle = source
                 .signal_vec()
@@ -8293,14 +8407,12 @@ pub(crate) mod tests {
             let mut app = create_test_app();
             app.init_resource::<SignalVecOutput<u32>>();
 
-            let vec_a = MutableVecBuilder::from([10u32, 11]).spawn(app.world_mut());
-            let vec_b = MutableVecBuilder::from([20u32]).spawn(app.world_mut());
+            let vec_a = MutableVec::builder().values([10u32, 11]).spawn(app.world_mut());
+            let vec_b = MutableVec::builder().values([20u32]).spawn(app.world_mut());
 
-            let source = MutableVecBuilder::from([
-                vec_a.signal_vec(),
-                vec_b.signal_vec(),
-            ])
-            .spawn(app.world_mut());
+            let source = MutableVec::builder()
+                .values([vec_a.signal_vec(), vec_b.signal_vec()])
+                .spawn(app.world_mut());
 
             let handle = source
                 .signal_vec()
@@ -8328,4 +8440,5 @@ pub(crate) mod tests {
         }
 
         cleanup(true);
-    }}
\ No newline at end of file
+    }
+}

From c842a0456776a0ffa19eab50dc80c7072ee45517 Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Sat, 24 Jan 2026 17:12:04 -0800
Subject: [PATCH 12/15] check

---
 CHANGELOG.md                     |  19 ++-
 README.md                        |   2 +-
 examples/basic_builder.rs        |  17 +-
 examples/basic_builder_inject.rs |   5 +-
 examples/counter.rs              |   6 +-
 examples/filters.rs              |  16 +-
 examples/lifetimes.rs            |   2 +-
 src/builder.rs                   |  38 +++--
 src/signal.rs                    | 275 ++++++++++++++++---------------
 src/utils.rs                     |   7 +
 10 files changed, 214 insertions(+), 173 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9197bd2..8d680e9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,18 +7,24 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 ### changed
 
 - signal graph processed in deterministic topological order instead of the previous nondeterministic depth first order
-- renamed `SignalExt::combine` to `SignalExt::with`
+- `SignalBuilder::*` methods moved to free functions in the `signal` module (e.g. `SignalBuilder::always` -> `signal::always`)
 - `JonmoBuilder` renamed to `jonmo::Builder`
+- `jonmo::Builder` is now lock-free
 - `jonmo::Builder::hold_signals` renamed to `jonmo::Builder::hold_tasks` and takes `Box<dyn SignalTask>`s instead of `SignalHandles`
+- renamed `SignalExt::combine` to `SignalExt::zip`
+- `MutableVecBuilder`/`MutableBTreeMapBuilder` changed to `MutableVec::builder()`/`MutableBTreeMap::builder()` with simple chainable `.values` and `.with_values` methods
 - removed self item `Clone` bound from `SignalVecExt::map_signal` and `SignalVecExt::filter_map`
-- `SignalBuilder::*` methods moved to free functions in `signal` module (e.g. `SignalBuilder::always` -> `signal::always`)
+- `.get_mut`s unwrapped and `.get_entity_mut`s changed to `.entity_mut` in cases where they were silently ignoring invariant violations
 
 ### added
+- `signal::once`
+- `signal::from_component_changed`
+- `signal::from_resource_changed`
+- `signal::zip!`, a variadic flattened version of `SignalExt::zip`
 - `SignalExt::take`
-- `signal::zip!`, a variadic flattened version of `SignalExt::with`
 - `SignalVecExt::flatten`
 - `track_caller` derive for panicking `LazyEntity` methods
-- warning that cloning `jonmo::Builder`s at runtime is a bug
+- panic (debug only) or error log that cloning `jonmo::Builder`s at runtime is a bug
 
 ### fixed
 
@@ -26,6 +32,11 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 - initially empty `MutableVec/BTreeMap`s work as expected when output to `.switch_signal_vec/map`
 - `SignalVecExt::debug` and `SignalMapExt::debug` now log correct code location
 
+### removed
+- `*_lazy` signal builder functions, the non-`lazy` versions now take both `Entity` and `LazyEntity`
+- `jonmo::Builder::signal_from_*` methods, use corresponding `signal` building functions with `.task()` and `jonmo::Builder::hold_tasks` instead
+- `jonmo::Builder::component_signal_from_*` methods, use corresponding `signal` building functions with `jonmo::Builder::component_signal` instead
+
 # 0.5.0 (2025-12-19)
 
 ### changed
diff --git a/README.md b/README.md
index 0ed0806..1870c6a 100644
--- a/README.md
+++ b/README.md
@@ -75,7 +75,7 @@ fn ui_root() -> jonmo::Builder {
         .child(
             jonmo::Builder::from((Node::default(), TextFont::from_font_size(25.)))
                 .component_signal(
-                    signal::from_component_changed_lazy::<Counter>(counter_holder.clone())
+                    signal::from_component_changed::<Counter>(counter_holder.clone())
                         .map_in(deref_copied)
                         .map_in_ref(ToString::to_string)
                         .map_in(Text)
diff --git a/examples/basic_builder.rs b/examples/basic_builder.rs
index f14e903..a308b1e 100644
--- a/examples/basic_builder.rs
+++ b/examples/basic_builder.rs
@@ -26,11 +26,10 @@ fn main() {
 #[derive(Resource, Deref, DerefMut)]
 struct ValueTicker(Timer);
 
-#[derive(Component, Clone, Default, PartialEq)]
+#[derive(Component, Clone, Default, PartialEq, Deref)]
 struct Value(i32);
 
 fn ui() -> jonmo::Builder {
-    let lazy_entity = LazyEntity::new();
     jonmo::Builder::from(Node {
         justify_content: JustifyContent::Center,
         align_items: AlignItems::Center,
@@ -38,17 +37,19 @@ fn ui() -> jonmo::Builder {
         width: Val::Percent(100.),
         ..default()
     })
-    .lazy_entity(lazy_entity.clone())
-    .child(
+    .child({
+        let lazy_entity = LazyEntity::new();
         jonmo::Builder::from((Node::default(), TextFont::from_font_size(100.)))
+            .lazy_entity(lazy_entity.clone())
             .insert(Value(0))
             .component_signal(
-                signal::from_component_changed_lazy::<Value>(lazy_entity)
-                    .map_in(|value| value.0.to_string())
+                signal::from_component_changed::<Value>(lazy_entity)
+                    .map_in(deref_copied)
+                    .map_in_ref(ToString::to_string)
                     .map_in(Text)
                     .map_in(Some),
-            ),
-    )
+            )
+    })
 }
 
 fn incr_value(mut ticker: ResMut<ValueTicker>, time: Res<Time>, mut values: Query<&mut Value>) {
diff --git a/examples/basic_builder_inject.rs b/examples/basic_builder_inject.rs
index e7abf02..c56d18c 100644
--- a/examples/basic_builder_inject.rs
+++ b/examples/basic_builder_inject.rs
@@ -18,7 +18,7 @@ fn main() {
 #[derive(Resource, Deref, DerefMut)]
 struct ValueTicker(Timer);
 
-#[derive(Component, Clone, Default, PartialEq)]
+#[derive(Component, Clone, Default, PartialEq, Deref)]
 struct Value(i32);
 
 fn ui(world: &mut World) {
@@ -37,7 +37,8 @@ fn ui(world: &mut World) {
     jonmo::Builder::new()
         .component_signal(
             signal::from_component_changed::<Value>(text)
-                .map_in(|value| value.0.to_string())
+                .map_in(deref_copied)
+                .map_in_ref(ToString::to_string)
                 .map_in(Text)
                 .map_in(Some),
         )
diff --git a/examples/counter.rs b/examples/counter.rs
index 9f5d49d..98ed967 100644
--- a/examples/counter.rs
+++ b/examples/counter.rs
@@ -65,7 +65,7 @@ fn ui_root() -> jonmo::Builder {
         })
         .insert(Counter(0))
         // `.lazy_entity()` connects the `LazyEntity` to the actual entity that this `jonmo::Builder` spawns. Now
-        // calling `counter_holder.get()` from other deferred contexts, e.g. in the bodies of signal systems,
+        // calling `*counter_holder` from other deferred contexts, e.g. in the bodies of signal systems,
         // will return the `Entity` ID of this row node.
         .lazy_entity(counter_holder.clone())
         .child(counter_button(counter_holder.clone(), PINK, "-", -1))
@@ -76,10 +76,10 @@ fn ui_root() -> jonmo::Builder {
                 // we're creating a signal that will produce a `Text` component whenever the counter
                 // changes.
                 .component_signal(
-                    // `signal::from_component_changed_lazy` creates a signal that reactively reads a component from an
+                    // `signal::from_component_changed` creates a signal that reactively reads a component from an
                     // entity that doesn't exist yet, identified by our `LazyEntity`, only firing when the component
                     // changes.
-                    signal::from_component_changed_lazy::<Counter>(counter_holder.clone())
+                    signal::from_component_changed::<Counter>(counter_holder.clone())
                         // `map_in` is a shorthand for `.map` that takes a regular function instead of a Bevy
                         // system; this is especially convenient when additional `SystemParam`s aren't necessary.
                         // `deref_copied` dereferences and copies, extracting the inner `i32` from the `Counter`
diff --git a/examples/filters.rs b/examples/filters.rs
index 2665696..4be6869 100644
--- a/examples/filters.rs
+++ b/examples/filters.rs
@@ -234,7 +234,7 @@ fn number_toggle(row_parent: LazyEntity, parity: Parity) -> impl Fn(jonmo::Build
                 }),
             )
             .component_signal(
-                signal::from_component_changed_lazy(row_parent.clone())
+                signal::from_component_changed(row_parent.clone())
                     .map_in(move |NumberFilters(filters)| filters.contains(&parity))
                     .dedupe()
                     .map_true(|_: In<()>| outline()),
@@ -273,7 +273,7 @@ fn number_toggles(row_parent: LazyEntity) -> jonmo::Builder {
                 }),
             )
             .component_signal(
-                signal::from_lazy_entity(row_parent.clone())
+                signal::from_entity(row_parent.clone())
                     .has_component::<Sorted>()
                     .dedupe()
                     .map_true(|_: In<()>| outline()),
@@ -296,7 +296,7 @@ fn shape_toggle(row_parent: LazyEntity, shape: Shape) -> jonmo::Builder {
         }),
     )
     .component_signal(
-        signal::from_component_changed_lazy(row_parent.clone())
+        signal::from_component_changed(row_parent.clone())
             .map_in(move |ShapeFilters(filters)| filters.contains(&shape))
             .dedupe()
             .map_true(|_: In<()>| outline()),
@@ -342,7 +342,7 @@ fn color_toggles(row_parent: LazyEntity) -> jonmo::Builder {
                     }),
                 )
                 .component_signal(
-                    signal::from_component_changed_lazy(row_parent.clone())
+                    signal::from_component_changed(row_parent.clone())
                         .map_in(move |ColorFilters(filters)| filters.contains(&color))
                         .dedupe()
                         .map_true(|_: In<()>| outline()),
@@ -424,7 +424,7 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> jon
             ..default()
         },))
         .children_signal_vec(
-            signal::from_lazy_entity(row_parent.clone())
+            signal::from_entity(row_parent.clone())
                 .has_component::<Sorted>()
                 .dedupe()
                 .switch_signal_vec(move |In(sorted)| {
@@ -436,7 +436,7 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> jon
                     }
                 })
                 .filter_signal(clone!((row_parent) move | In((_, Data { number, .. })) | {
-                    signal::from_component_changed_lazy(row_parent.clone())
+                    signal::from_component_changed(row_parent.clone())
                         .map_in(move |number_filters: NumberFilters| {
                             number_filters.0.contains(&if number.is_multiple_of(2) {
                                 Parity::Even
@@ -447,12 +447,12 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> jon
                         .dedupe()
                 }))
                 .filter_signal(clone!((row_parent) move | In((_, Data { shape, .. })) | {
-                    signal::from_component_changed_lazy(row_parent.clone())
+                    signal::from_component_changed(row_parent.clone())
                         .map_in(move |shape_filters: ShapeFilters| shape_filters.0.contains(&shape))
                         .dedupe()
                 }))
                 .filter_signal(clone!((row_parent) move | In((_, Data { color, .. })) | {
-                    signal::from_component_changed_lazy(row_parent.clone())
+                    signal::from_component_changed(row_parent.clone())
                         .map_in(move |color_filters: ColorFilters| color_filters.0.contains(&color))
                         .dedupe()
                 }))
diff --git a/examples/lifetimes.rs b/examples/lifetimes.rs
index daa83f7..ab1fb69 100644
--- a/examples/lifetimes.rs
+++ b/examples/lifetimes.rs
@@ -223,7 +223,7 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> jonmo
                     // This is where the `LazyEntity` becomes powerful.
                     // We create a signal that reads a component from the entity that `lifetime_holder` will eventually
                     // point to.
-                    signal::from_component_changed_lazy(lifetime_holder)
+                    signal::from_component_changed(lifetime_holder)
                         // Map the `Lifetime` component to its inner `f32` value and round it.
                         .map_in(|Lifetime(lifetime)| lifetime.round())
                         // `dedupe` is a crucial optimization. It ensures the rest of the signal chain only runs
diff --git a/src/builder.rs b/src/builder.rs
index 0832cf3..0d82440 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -13,7 +13,7 @@ use bevy_ecs::{
     system::{IntoObserverSystem, RunSystemOnce},
     world::{DeferredWorld, error::EntityMutableFetchError},
 };
-use bevy_log::warn;
+use bevy_log::error;
 use bevy_platform::prelude::*;
 use core::sync::atomic::{AtomicUsize, Ordering};
 
@@ -69,10 +69,14 @@ impl Clone for Builder {
     /// ```
     #[track_caller]
     fn clone(&self) -> Self {
-        warn!(
+        let msg = format!(
             "Cloning `jonmo::Builder` at {} is a bug! Use a factory function instead.",
             core::panic::Location::caller()
         );
+        if cfg!(debug_assertions) {
+            panic!("{}", msg);
+        }
+        error!("{}", msg);
 
         Self::default()
     }
@@ -89,6 +93,15 @@ impl<T: Bundle> From<T> for Builder {
 #[derive(Component, Default)]
 struct ChildBlockPopulations(Vec<usize>);
 
+impl ChildBlockPopulations {
+    /// Ensure the vector is large enough to store population for the given block index.
+    fn ensure_block(&mut self, block: usize) {
+        if self.0.len() <= block {
+            self.0.resize(block + 1, 0);
+        }
+    }
+}
+
 impl Builder {
     #[allow(missing_docs)]
     pub fn new() -> Self {
@@ -290,9 +303,7 @@ impl Builder {
             let child_entity = world.spawn_empty().id();
             // Ensure the populations vec is large enough and set this block's population
             let mut pops = world.get_mut::<ChildBlockPopulations>(parent).unwrap();
-            if pops.0.len() <= block {
-                pops.0.resize(block + 1, 0);
-            }
+            pops.ensure_block(block);
             pops.0[block] = 1;
             let insert_offset = offset(block, &pops.0);
             // need to call like this to avoid type ambiguity
@@ -308,9 +319,7 @@ impl Builder {
         let on_spawn = move |world: &mut World, parent: Entity| {
             // Initialize this block's population to 0
             let mut pops = world.get_mut::<ChildBlockPopulations>(parent).unwrap();
-            if pops.0.len() <= block {
-                pops.0.resize(block + 1, 0);
-            }
+            pops.ensure_block(block);
 
             let system = move |In(child_option): In<Option<Builder>>,
                                world: &mut World,
@@ -351,9 +360,7 @@ impl Builder {
             }
             // Set this block's population
             let mut pops = world.get_mut::<ChildBlockPopulations>(parent).unwrap();
-            if pops.0.len() <= block {
-                pops.0.resize(block + 1, 0);
-            }
+            pops.ensure_block(block);
             pops.0[block] = population;
             let insert_offset = offset(block, &pops.0);
             world
@@ -372,9 +379,7 @@ impl Builder {
         let on_spawn = move |world: &mut World, parent: Entity| {
             // Initialize this block's population to 0
             let mut pops = world.get_mut::<ChildBlockPopulations>(parent).unwrap();
-            if pops.0.len() <= block {
-                pops.0.resize(block + 1, 0);
-            }
+            pops.ensure_block(block);
 
             let system = move |In(diffs): In<Vec<VecDiff<Builder>>>,
                                world: &mut World,
@@ -500,7 +505,6 @@ impl Builder {
     /// Spawn this builder into the [`World`].
     pub fn spawn(self, world: &mut World) -> Entity {
         let entity = world.spawn_empty().id();
-        // SAFETY: We just created this entity, so it must exist
         self.spawn_on_entity(world, entity).unwrap();
         entity
     }
@@ -1158,7 +1162,7 @@ mod tests {
             // Use LazyEntity + signal::Builder pattern instead of removed component_signal_from_parent
             let child_entity = LazyEntity::new();
             let child_builder_with_signal = jonmo::Builder::new().lazy_entity(child_entity.clone()).on_signal(
-                signal::from_parent_lazy(child_entity.clone())
+                signal::from_parent(child_entity.clone())
                     .component::<SourceComp>()
                     .map_in(|source: SourceComp| Some(TargetComp(source.0 * 2))),
                 |In((entity, comp_opt)): In<(Entity, Option<TargetComp>)>, world: &mut World| {
@@ -1485,7 +1489,7 @@ mod tests {
                     .insert(ChildCompD)
                     .child(jonmo::Builder::new().insert(GrandchildComp)) // Nested child
                     .on_signal(
-                        signal::from_parent_lazy(complex_child_entity.clone())
+                        signal::from_parent(complex_child_entity.clone())
                             .component::<SourceComp>()
                             .map_in(|source: SourceComp| Some(TargetComp(source.0 * 10))),
                         |In((entity, comp_opt)): In<(Entity, Option<TargetComp>)>, world: &mut World| {
diff --git a/src/signal.rs b/src/signal.rs
index db27eec..23a75a3 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -346,8 +346,8 @@ where
     }
 }
 
-/// Signal graph node which combines two upstreams, see [`.with`](SignalExt::with).
-pub struct With<Left, Right>
+/// Signal graph node which combines two upstreams, see [`.zip`](SignalExt::zip).
+pub struct Zip<Left, Right>
 where
     Left: Signal,
     Right: Signal,
@@ -356,7 +356,7 @@ where
     _marker: PhantomData<fn() -> (Left, Right)>,
 }
 
-impl<Left, Right> Clone for With<Left, Right>
+impl<Left, Right> Clone for Zip<Left, Right>
 where
     Left: Signal + Clone,
     Right: Signal + Clone,
@@ -369,17 +369,17 @@ where
     }
 }
 
-/// Internal cache for [`.with`](SignalExt::with) combinator.
+/// Internal cache for [`.zip`](SignalExt::zip) combinator.
 ///
 /// Each upstream updates its side. The gate signal runs once per frame and emits the latest
 /// combined output once both sides have produced at least one value.
 #[derive(Component)]
-struct WithCache<L, R> {
+struct ZipCache<L, R> {
     left: Option<L>,
     right: Option<R>,
 }
 
-impl<L, R> Default for WithCache<L, R> {
+impl<L, R> Default for ZipCache<L, R> {
     fn default() -> Self {
         Self {
             left: None,
@@ -388,7 +388,7 @@ impl<L, R> Default for WithCache<L, R> {
     }
 }
 
-impl<Left, Right> Signal for With<Left, Right>
+impl<Left, Right> Signal for Zip<Left, Right>
 where
     Left: Signal,
     Right: Signal,
@@ -960,7 +960,7 @@ where
     O: Clone + SSs,
     F: FnMut() -> O + SSs,
 {
-    from_system(move |_: In<()>| Some(f()))
+    from_system(move |_: In<()>| f())
 }
 
 /// Creates a [`Source`] signal that always outputs a constant value.
@@ -968,7 +968,7 @@ pub fn always<O>(value: O) -> Source<O>
 where
     O: Clone + SSs,
 {
-    from_system(move |_: In<()>| Some(value.clone()))
+    from_system(move |_: In<()>| value.clone())
 }
 
 /// Creates a [`Signal`] that outputs a value once and then terminates forever.
@@ -986,99 +986,73 @@ where
     })
 }
 
-/// Creates a [`Source`] signal from an [`Entity`].
-pub fn from_entity(entity: Entity) -> Source<Entity> {
-    from_system(move |_: In<()>| entity)
-}
-
-/// Creates a [`Source`] signal from a [`LazyEntity`].
-pub fn from_lazy_entity(entity: LazyEntity) -> Source<Entity> {
-    from_system(move |_: In<()>| *entity)
+/// Creates a [`Source`] signal from an [`Entity`] or [`LazyEntity`].
+pub fn from_entity(entity: impl Into<Entity> + SSs) -> Source<Entity> {
+    let mut entity = Some(entity);
+    from_system(move |_: In<()>, mut cached: Local<Option<Entity>>| {
+        *cached.get_or_insert_with(|| entity.take().unwrap().into())
+    })
 }
 
-/// Creates a [`Source`] signal from an [`Entity`]'s `generations`-th generation ancestor's
-/// [`Entity`], terminating for frames where it does not exist. Passing `0` to `generation` will
-/// output the [`Entity`] itself.
-pub fn from_ancestor(entity: Entity, generations: usize) -> Map<Source<Entity>, Entity> {
+/// Creates a [`Source`] signal from an [`Entity`]'s or [`LazyEntity`]'s `generations`-th generation
+/// ancestor's [`Entity`], terminating for frames where it does not exist. Passing `0` to
+/// `generation` will output the [`Entity`] itself.
+pub fn from_ancestor(entity: impl Into<Entity> + SSs, generations: usize) -> Map<Source<Entity>, Entity> {
     from_entity(entity).map(ancestor_map(generations))
 }
 
-/// Creates a [`Source`] signal from a [`LazyEntity`]'s `generations`-th generation ancestor's
-/// [`Entity`], terminating for frames where it does not exist. Passing `0` to `generation` will
-/// output the [`LazyEntity`]'s  [`Entity`] itself.
-pub fn from_ancestor_lazy(entity: LazyEntity, generations: usize) -> Map<Source<Entity>, Entity> {
-    from_lazy_entity(entity).map(ancestor_map(generations))
-}
-
-/// Creates a [`Source`] signal from an [`Entity`]'s parent's [`Entity`], terminating for frames
-/// where it does not exist. Passing `0` to `generation` will output the [`Entity`] itself.
-pub fn from_parent(entity: Entity) -> Map<Source<Entity>, Entity> {
+/// Creates a [`Source`] signal from an [`Entity`]'s or [`LazyEntity`]'s parent's [`Entity`],
+/// terminating for frames where it does not exist.
+pub fn from_parent(entity: impl Into<Entity> + SSs) -> Map<Source<Entity>, Entity> {
     from_ancestor(entity, 1)
 }
 
-/// Creates a [`Source`] signal from a [`LazyEntity`]'s parent's [`Entity`], terminating for
-/// frames where it does not exist. Passing `0` to `generation` will output the
-/// [`LazyEntity`]'s [`Entity`] itself.
-pub fn from_parent_lazy(entity: LazyEntity) -> Map<Source<Entity>, Entity> {
-    from_ancestor_lazy(entity, 1)
-}
-
-/// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], terminating for the
-/// frame if the [`Entity`] does not exist or the [`Component`] does not exist on the
-/// [`Entity`].
-pub fn from_component<C>(entity: Entity) -> Source<C>
-where
-    C: Component + Clone,
-{
-    from_system(move |_: In<()>, components: Query<&C>| components.get(entity).ok().cloned())
-}
-
-/// Creates a [`Source`] signal from a [`LazyEntity`] and a [`Component`], terminating for the
-/// frame if the [`Entity`] does not exist or the [`Component`] does not exist on the
-/// corresponding [`Entity`].
-pub fn from_component_lazy<C>(entity: LazyEntity) -> Source<C>
-where
-    C: Component + Clone,
-{
-    from_system(move |_: In<()>, components: Query<&C>| components.get(*entity).ok().cloned())
-}
-
-/// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], always outputting an
-/// [`Option`].
-pub fn from_component_option<C>(entity: Entity) -> Source<Option<C>>
+/// Creates a [`Source`] signal from an [`Entity`] or [`LazyEntity`] and a [`Component`],
+/// terminating for the frame if the [`Entity`] does not exist or the [`Component`] does not exist
+/// on the [`Entity`].
+pub fn from_component<C>(entity: impl Into<Entity> + SSs) -> Source<C>
 where
     C: Component + Clone,
 {
-    from_system(move |_: In<()>, components: Query<&C>| Some(components.get(entity).ok().cloned()))
+    let mut entity = Some(entity);
+    from_system(
+        move |_: In<()>, mut cached: Local<Option<Entity>>, components: Query<&C>| {
+            let entity = *cached.get_or_insert_with(|| entity.take().unwrap().into());
+            components.get(entity).ok().cloned()
+        },
+    )
 }
 
-/// Creates a [`Source`] signal from a [`LazyEntity`] and a [`Component`], always outputting an
-/// [`Option`].
-pub fn from_component_option_lazy<C>(entity: LazyEntity) -> Source<Option<C>>
+/// Creates a [`Source`] signal from an [`Entity`] or [`LazyEntity`] and a [`Component`], always
+/// outputting an [`Option`].
+pub fn from_component_option<C>(entity: impl Into<Entity> + SSs) -> Source<Option<C>>
 where
     C: Component + Clone,
 {
-    from_system(move |_: In<()>, components: Query<&C>| Some(components.get(*entity).ok().cloned()))
+    let mut entity = Some(entity);
+    from_system(
+        move |_: In<()>, mut cached: Local<Option<Entity>>, components: Query<&C>| {
+            let entity = *cached.get_or_insert_with(|| entity.take().unwrap().into());
+            Some(components.get(entity).ok().cloned())
+        },
+    )
 }
 
-/// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], only outputting on
-/// frames where the [`Component`] has [`Changed`]. Terminates for the frame if the [`Entity`]
-/// does not exist, the [`Component`] does not exist, or the [`Component`] has not changed.
-pub fn from_component_changed<C>(entity: Entity) -> Source<C>
+/// Creates a [`Source`] signal from an [`Entity`] or [`LazyEntity`] and a [`Component`], only
+/// outputting on frames where the [`Component`] has [`Changed`]. Terminates for the frame if the
+/// [`Entity`] does not exist, the [`Component`] does not exist, or the [`Component`] has not
+/// changed.
+pub fn from_component_changed<C>(entity: impl Into<Entity> + SSs) -> Source<C>
 where
     C: Component + Clone,
 {
-    from_system(move |_: In<()>, components: Query<&C, Changed<C>>| components.get(entity).ok().cloned())
-}
-
-/// Creates a [`Source`] signal from a [`LazyEntity`] and a [`Component`], only outputting on
-/// frames where the [`Component`] has [`Changed`]. Terminates for the frame if the [`Entity`]
-/// does not exist, the [`Component`] does not exist, or the [`Component`] has not changed.
-pub fn from_component_changed_lazy<C>(entity: LazyEntity) -> Source<C>
-where
-    C: Component + Clone,
-{
-    from_system(move |_: In<()>, components: Query<&C, Changed<C>>| components.get(*entity).ok().cloned())
+    let mut entity = Some(entity);
+    from_system(
+        move |_: In<()>, mut cached: Local<Option<Entity>>, components: Query<&C, Changed<C>>| {
+            let entity = *cached.get_or_insert_with(|| entity.take().unwrap().into());
+            components.get(entity).ok().cloned()
+        },
+    )
 }
 
 /// Creates a signal from a [`Resource`], terminating for the frame if the [`Resource`] does not
@@ -1700,9 +1674,9 @@ pub trait SignalExt: Signal {
     ///
     /// let signal_1 = signal::from_system(|_: In<()>| 1);
     /// let signal_2 = signal::from_system(|_: In<()>| 2);
-    /// signal_1.with(signal_2); // outputs `(1, 2)`
+    /// signal_1.zip(signal_2); // outputs `(1, 2)`
     /// ```
-    fn with<Other>(self, other: Other) -> With<Self, Other>
+    fn zip<Other>(self, other: Other) -> Zip<Self, Other>
     where
         Self: Sized,
         Other: Signal,
@@ -1710,22 +1684,20 @@ pub trait SignalExt: Signal {
         Other::Item: Clone + SSs,
     {
         let signal = LazySignal::new(move |world: &mut World| {
-            let with_entity = LazyEntity::new();
+            let zip_entity = LazyEntity::new();
 
-            let left_wrapper = self.map(
-                clone!((with_entity) move |In(left): In<Self::Item>, world: &mut World| {
-                    world.get_mut::<WithCache<Self::Item, Other::Item>>(*with_entity).unwrap().left = Some(left);
-                }),
-            );
+            let left_wrapper = self.map(clone!((zip_entity) move |In(left): In<Self::Item>, world: &mut World| {
+                world.get_mut::<ZipCache<Self::Item, Other::Item>>(*zip_entity).unwrap().left = Some(left);
+            }));
             let right_wrapper = other.map(
-                clone!((with_entity) move |In(right): In<Other::Item>, world: &mut World| {
-                    world.get_mut::<WithCache<Self::Item, Other::Item>>(*with_entity).unwrap().right = Some(right);
+                clone!((zip_entity) move |In(right): In<Other::Item>, world: &mut World| {
+                    world.get_mut::<ZipCache<Self::Item, Other::Item>>(*zip_entity).unwrap().right = Some(right);
                 }),
             );
 
-            let with_signal = lazy_signal_from_system::<_, (Self::Item, Other::Item), _, _, _>(
-                clone!((with_entity) move |_: In<()>, world: &mut World| {
-                    let cache = world.get_mut::<WithCache<Self::Item, Other::Item>>(*with_entity).unwrap();
+            let zip_signal = lazy_signal_from_system::<_, (Self::Item, Other::Item), _, _, _>(
+                clone!((zip_entity) move |_: In<()>, world: &mut World| {
+                    let cache = world.get_mut::<ZipCache<Self::Item, Other::Item>>(*zip_entity).unwrap();
                     match (&cache.left, &cache.right) {
                         (Some(left), Some(right)) => Some((left.clone(), right.clone())),
                         _ => None,
@@ -1733,11 +1705,11 @@ pub trait SignalExt: Signal {
                 }),
             );
 
-            let signal = with_signal.register(world);
+            let signal = zip_signal.register(world);
             world
                 .entity_mut(*signal)
-                .insert(WithCache::<Self::Item, Other::Item>::default());
-            with_entity.set(*signal);
+                .insert(ZipCache::<Self::Item, Other::Item>::default());
+            zip_entity.set(*signal);
 
             let SignalHandle(left_upstream) = left_wrapper.register(world);
             let SignalHandle(right_upstream) = right_wrapper.register(world);
@@ -1747,7 +1719,7 @@ pub trait SignalExt: Signal {
             signal
         });
 
-        With {
+        Zip {
             signal,
             _marker: PhantomData,
         }
@@ -2921,7 +2893,7 @@ impl<T: ?Sized> SignalExt for T where T: Signal {}
 macro_rules! eq {
     // Entry point
     ($s1:expr, $s2:expr $(, $rest:expr)* $(,)?) => {
-        $crate::__signal_with_and_map!($s1, $s2 $(, $rest)*; |val| {
+        $crate::__signal_zip_and_map!($s1, $s2 $(, $rest)*; |val| {
             $crate::eq!(@check val, $s1, $s2 $(, $rest)*)
         })
     };
@@ -2939,32 +2911,32 @@ macro_rules! eq {
 
 #[doc(hidden)]
 #[macro_export]
-macro_rules! __signal_with_and_map {
+macro_rules! __signal_zip_and_map {
     // Single argument case
     ($s1:expr $(,)?; |$val:ident| $body:block) => {
         $s1.map(|In($val)| $body)
     };
     // Entry point
     ($s1:expr, $s2:expr $(, $rest:expr)* $(,)?; |$val:ident| $body:block) => {
-        $crate::__signal_with_and_map!(@combine $s1, $s2 $(, $rest)*)
-            .map(|In($val @ $crate::__signal_with_and_map!(@pattern $s1, $s2 $(, $rest)*))| $body)
+        $crate::__signal_zip_and_map!(@combine $s1, $s2 $(, $rest)*)
+            .map(|In($val @ $crate::__signal_zip_and_map!(@pattern $s1, $s2 $(, $rest)*))| $body)
     };
 
     // Combine chain
     (@combine $first:expr, $second:expr) => {
-        $first.with($second)
+        $first.zip($second)
     };
     (@combine $first:expr, $second:expr, $($rest:expr),+) => {
-        $crate::__signal_with_and_map!(@combine $first.with($second), $($rest),+)
+        $crate::__signal_zip_and_map!(@combine $first.zip($second), $($rest),+)
     };
 
     // Pattern generator (nested tuple of `_` matching the combine nesting)
     (@pattern $s1:expr, $s2:expr $(, $rest:expr)*) => {
-        $crate::__signal_with_and_map!(@pattern_helper (_, _) $(, $rest)*)
+        $crate::__signal_zip_and_map!(@pattern_helper (_, _) $(, $rest)*)
     };
     (@pattern_helper $acc:tt $(,)?) => { $acc };
     (@pattern_helper $acc:tt, $head:expr $(, $tail:expr)*) => {
-        $crate::__signal_with_and_map!(@pattern_helper ($acc, _) $(, $tail)*)
+        $crate::__signal_zip_and_map!(@pattern_helper ($acc, _) $(, $tail)*)
     };
 }
 
@@ -3104,7 +3076,7 @@ macro_rules! __signal_reduce_binop {
     };
     // Entry point
     ($op:tt; $s1:expr, $s2:expr $(, $rest:expr)* $(,)?) => {
-        $crate::__signal_with_and_map!($s1, $s2 $(, $rest)*; |val| {
+        $crate::__signal_zip_and_map!($s1, $s2 $(, $rest)*; |val| {
             $crate::__signal_reduce_binop!(@apply $op, val, $s1, $s2 $(, $rest)*)
         })
     };
@@ -3200,7 +3172,7 @@ macro_rules! __signal_reduce_cmp {
     };
     // Entry point
     ($cmp:tt; $s1:expr, $s2:expr $(, $rest:expr)* $(,)?) => {
-        $crate::__signal_with_and_map!($s1, $s2 $(, $rest)*; |val| {
+        $crate::__signal_zip_and_map!($s1, $s2 $(, $rest)*; |val| {
             $crate::__signal_reduce_cmp!(@select $cmp, val, $s1, $s2 $(, $rest)*)
         })
     };
@@ -3220,7 +3192,7 @@ macro_rules! __signal_reduce_cmp {
 }
 
 /// Zips multiple [`Signal`]s into a single [`Signal`] that outputs a flat tuple of all their
-/// outputs. Unlike chaining [`.with()`](SignalExt::with) calls which produces nested tuples
+/// outputs. Unlike chaining [`.zip()`](SignalExt::zip) calls which produces nested tuples
 /// like `(((A, B), C), D)`, this macro produces flat tuples like `(A, B, C, D)`.
 ///
 /// The resulting [`Signal`] will only output a value when all input [`Signal`]s have outputted a
@@ -3242,7 +3214,7 @@ macro_rules! __signal_reduce_cmp {
 /// // Outputs a flat tuple (i32, &str, f64, bool)
 /// let zipped = signal::zip!(s1, s2, s3, s4);
 ///
-/// // Compare to chained .with() which would give (((i32, &str), f64), bool)
+/// // Compare to chained .zip() which would give (((i32, &str), f64), bool)
 /// ```
 #[macro_export]
 macro_rules! zip {
@@ -3250,13 +3222,13 @@ macro_rules! zip {
     ($s1:expr $(,)?) => {
         $s1.map(|In(__v)| (__v,))
     };
-    // Two signals - use with directly (already flat)
+    // Two signals - use zip directly (already flat)
     ($s1:expr, $s2:expr $(,)?) => {
-        $s1.with($s2)
+        $s1.zip($s2)
     };
     // Three or more signals - build combine chain then flatten
     ($s1:expr, $s2:expr $(, $rest:expr)+ $(,)?) => {
-        $crate::__signal_with_and_map!($s1, $s2 $(, $rest)+; |__v| {
+        $crate::__signal_zip_and_map!($s1, $s2 $(, $rest)+; |__v| {
             $crate::__signal_zip_flatten!(__v; $s1, $s2 $(, $rest)+;)
         })
     };
@@ -3807,11 +3779,11 @@ mod tests {
     }
 
     #[test]
-    fn test_with() {
+    fn test_zip() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<(i32, &'static str)>>();
         let signal = signal::from_system(move |_: In<()>| 10)
-            .with(signal::from_system(move |_: In<()>| "hello"))
+            .zip(signal::from_system(move |_: In<()>| "hello"))
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -3820,7 +3792,7 @@ mod tests {
     }
 
     #[test]
-    fn test_with_emits_after_both_emit() {
+    fn test_zip_emits_after_both_emit() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutputVec<(i32, i32)>>();
 
@@ -3830,7 +3802,7 @@ mod tests {
         });
         let right = signal::from_system(|_: In<()>| 10).first();
 
-        let signal = left.with(right).map(capture_output_vec).register(app.world_mut());
+        let signal = left.zip(right).map(capture_output_vec).register(app.world_mut());
 
         app.update();
         assert_eq!(
@@ -3867,7 +3839,7 @@ mod tests {
     }
 
     #[test]
-    fn test_fan_out_fan_in_with() {
+    fn test_fan_out_fan_in_zip() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<(i32, i32)>>();
 
@@ -3879,7 +3851,7 @@ mod tests {
         let left = source.clone().map_in(|x: i32| x + 1);
         let right = source.map_in(|x: i32| x + 10);
 
-        let signal = left.with(right).map(capture_output).register(app.world_mut());
+        let signal = left.zip(right).map(capture_output).register(app.world_mut());
 
         app.update();
         assert_eq!(get_output::<(i32, i32)>(app.world()), Some((2, 11)));
@@ -3902,7 +3874,7 @@ mod tests {
         assert_eq!(get_output::<(i32,)>(app.world()), Some((1,)));
         signal.cleanup(app.world_mut());
 
-        // Test 2 signals - same as .with()
+        // Test 2 signals - same as .zip()
         app.init_resource::<SignalOutput<(i32, &'static str)>>();
         let s1 = signal::from_system(|_: In<()>| 1);
         let s2 = signal::from_system(|_: In<()>| "two");
@@ -4950,6 +4922,53 @@ mod tests {
         signal.cleanup(app.world_mut());
     }
 
+    #[test]
+    fn test_builder_from_function() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<i32>>();
+
+        // Test basic FnMut closure
+        let counter = Arc::new(Mutex::new(0));
+        let signal = signal::from_function(clone!((counter) move || {
+            let mut c = counter.lock().unwrap();
+            *c += 1;
+            *c
+        }))
+        .map(capture_output)
+        .register(app.world_mut());
+
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(1));
+
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(2));
+
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(3));
+
+        signal.cleanup(app.world_mut());
+    }
+
+    #[test]
+    fn test_builder_always() {
+        let mut app = create_test_app();
+        app.init_resource::<SignalOutput<i32>>();
+
+        let signal = signal::always(42).map(capture_output).register(app.world_mut());
+
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(42));
+
+        // Verify it still outputs the same value on subsequent updates
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(42));
+
+        app.update();
+        assert_eq!(get_output::<i32>(app.world()), Some(42));
+
+        signal.cleanup(app.world_mut());
+    }
+
     #[test]
     fn test_builder_from_entity() {
         let mut app = create_test_app();
@@ -4974,9 +4993,7 @@ mod tests {
         let test_entity = app.world_mut().spawn_empty().id();
         lazy.set(test_entity);
 
-        let signal = signal::from_lazy_entity(lazy)
-            .map(capture_output)
-            .register(app.world_mut());
+        let signal = signal::from_entity(lazy).map(capture_output).register(app.world_mut());
 
         app.update();
         assert_eq!(get_output::<Entity>(app.world()), Some(test_entity));
@@ -5046,7 +5063,7 @@ mod tests {
         lazy_child.set(child);
 
         // Test parent (generations = 1)
-        let signal_parent = signal::from_ancestor_lazy(lazy_child.clone(), 1)
+        let signal_parent = signal::from_ancestor(lazy_child.clone(), 1)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5054,7 +5071,7 @@ mod tests {
         signal_parent.cleanup(app.world_mut());
 
         // Test grandparent (generations = 2)
-        let signal_gp = signal::from_ancestor_lazy(lazy_child, 2)
+        let signal_gp = signal::from_ancestor(lazy_child, 2)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5102,7 +5119,7 @@ mod tests {
         app.world_mut().entity_mut(parent).add_child(child);
         lazy_child.set(child);
 
-        let signal = signal::from_parent_lazy(lazy_child)
+        let signal = signal::from_parent(lazy_child)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5148,7 +5165,7 @@ mod tests {
         let entity_with = app.world_mut().spawn(TestData(42)).id();
         lazy.set(entity_with);
 
-        let signal = signal::from_component_lazy::<TestData>(lazy)
+        let signal = signal::from_component::<TestData>(lazy)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5193,7 +5210,7 @@ mod tests {
         let entity_with = app.world_mut().spawn(TestData(42)).id();
         lazy.set(entity_with);
 
-        let signal = signal::from_component_option_lazy::<TestData>(lazy)
+        let signal = signal::from_component_option::<TestData>(lazy)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -5313,7 +5330,7 @@ mod tests {
         let entity = app.world_mut().spawn(TestData(42)).id();
         lazy.set(entity);
 
-        let signal = signal::from_component_changed_lazy::<TestData>(lazy)
+        let signal = signal::from_component_changed::<TestData>(lazy)
             .map(capture_output)
             .register(app.world_mut());
 
diff --git a/src/utils.rs b/src/utils.rs
index 86ee50e..7d53b39 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -41,6 +41,13 @@ impl Deref for LazyEntity {
     }
 }
 
+impl From<LazyEntity> for Entity {
+    #[track_caller]
+    fn from(lazy: LazyEntity) -> Entity {
+        lazy.get()
+    }
+}
+
 pub(crate) fn get_ancestor(child_ofs: &Query<&ChildOf>, entity: Entity, generations: usize) -> Option<Entity> {
     [entity]
         .into_iter()

From edd42bc3ee4e795b1f1127d551dfe1bea04fbf9c Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Sat, 24 Jan 2026 17:40:15 -0800
Subject: [PATCH 13/15] fix ci

---
 src/builder.rs    |  4 ++--
 src/graph.rs      |  6 ++----
 src/signal.rs     | 10 ++++++----
 src/signal_map.rs |  4 +---
 src/signal_vec.rs | 10 +++++-----
 5 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 0d82440..1d96654 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -13,7 +13,6 @@ use bevy_ecs::{
     system::{IntoObserverSystem, RunSystemOnce},
     world::{DeferredWorld, error::EntityMutableFetchError},
 };
-use bevy_log::error;
 use bevy_platform::prelude::*;
 use core::sync::atomic::{AtomicUsize, Ordering};
 
@@ -76,7 +75,8 @@ impl Clone for Builder {
         if cfg!(debug_assertions) {
             panic!("{}", msg);
         }
-        error!("{}", msg);
+        #[cfg(feature = "tracing")]
+        bevy_log::error!("{}", msg);
 
         Self::default()
     }
diff --git a/src/graph.rs b/src/graph.rs
index 38a4e68..df59595 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -10,8 +10,6 @@ use bevy_ecs::{
     system::{SystemId, SystemState},
     world::DeferredWorld,
 };
-#[cfg(feature = "tracing")]
-use bevy_log::prelude::*;
 use bevy_platform::{
     collections::{HashMap, HashSet},
     prelude::*,
@@ -118,7 +116,7 @@ pub(crate) fn pipe_signal(world: &mut World, source: SignalSystem, target: Signa
     if would_create_cycle(world, source, target) {
         // TODO: panic instead ?
         #[cfg(feature = "tracing")]
-        error!("cycle detected when attempting to pipe {:?} → {:?}", source, target);
+        bevy_log::error!("cycle detected when attempting to pipe {:?} → {:?}", source, target);
         return;
     }
     let mut upstream = world.entity_mut(*source);
@@ -176,7 +174,7 @@ where
                 cfg_if::cfg_if! {
                     if #[cfg(feature = "tracing")] {
                         let expected_type = core::any::type_name::<I>();
-                        error!(
+                        bevy_log::error!(
                             "failed to downcast input for system {:?}. expected input type: `{}`",
                             self.system, expected_type
                         );
diff --git a/src/signal.rs b/src/signal.rs
index 23a75a3..ff98a60 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -13,7 +13,6 @@ use crate::prelude::clone;
 use bevy_ecs::{entity_disabling::Internal, prelude::*, system::SystemState};
 cfg_if::cfg_if! {
     if #[cfg(feature = "tracing")] {
-        use bevy_log::prelude::*;
         use core::fmt;
     }
 }
@@ -2804,7 +2803,7 @@ pub trait SignalExt: Signal {
         let location = core::panic::Location::caller();
         Debug {
             signal: self.map(move |In(item)| {
-                debug!("[{}] {:#?}", location, item);
+                bevy_log::debug!("[{}] {:#?}", location, item);
                 item
             }),
         }
@@ -3303,9 +3302,12 @@ mod tests {
 
     // Helper system to capture signal output
     fn capture_output<T: SSs + Clone + fmt::Debug>(In(value): In<T>, mut output: ResMut<SignalOutput<T>>) {
-        debug!(
+        #[cfg(feature = "tracing")]
+        bevy_log::debug!(
             "Capture Output System: Received {:?}, updating resource from {:?} to Some({:?})",
-            value, output.0, value
+            value,
+            output.0,
+            value
         );
         output.0 = Some(value);
     }
diff --git a/src/signal_map.rs b/src/signal_map.rs
index 25bc47e..c16ff81 100644
--- a/src/signal_map.rs
+++ b/src/signal_map.rs
@@ -12,8 +12,6 @@ use super::{
 use crate::prelude::clone;
 use alloc::collections::BTreeMap;
 use bevy_ecs::{entity_disabling::Internal, prelude::*};
-#[cfg(feature = "tracing")]
-use bevy_log::debug;
 use bevy_platform::{
     prelude::*,
     sync::{Arc, LazyLock, Mutex},
@@ -901,7 +899,7 @@ pub trait SignalMapExt: SignalMap {
         let location = core::panic::Location::caller();
         Debug {
             signal: self.for_each(move |In(item)| {
-                debug!("[{}] {:#?}", location, item);
+                bevy_log::debug!("[{}] {:#?}", location, item);
                 item
             }),
         }
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index a549b1a..6c77606 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -11,8 +11,6 @@ use super::{
 use crate::prelude::clone;
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{change_detection::Mut, entity_disabling::Internal, prelude::*, system::SystemId};
-#[cfg(feature = "tracing")]
-use bevy_log::debug;
 use bevy_platform::{
     collections::{HashMap, HashSet},
     prelude::*,
@@ -3877,7 +3875,7 @@ pub trait SignalVecExt: SignalVec {
         let location = core::panic::Location::caller();
         Debug {
             signal: self.for_each(move |In(item)| {
-                debug!("[{}] {:#?}", location, item);
+                bevy_log::debug!("[{}] {:#?}", location, item);
                 item
             }),
         }
@@ -4528,9 +4526,11 @@ pub(crate) mod tests {
     where
         T: SSs + Clone + fmt::Debug,
     {
-        debug!(
+        #[cfg(feature = "tracing")]
+        bevy_log::debug!(
             "Capture SignalVec Output: Received {:?}, extending resource from {:?} with new diffs",
-            diffs, output.0
+            diffs,
+            output.0
         );
         output.0.extend(diffs);
     }

From 686c49464f5e3973b8452a82bb7da207b3d48c07 Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Sat, 24 Jan 2026 21:49:54 -0800
Subject: [PATCH 14/15] check

---
 src/signal.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/signal.rs b/src/signal.rs
index ff98a60..bd7c6d2 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -1981,12 +1981,11 @@ pub trait SignalExt: Signal {
                     // signal and poke the output signal.
                     let forwarder_logic = move |In(diffs): In<Vec<VecDiff<S::Item>>>, world: &mut World| {
                         if !diffs.is_empty() {
-                            world
-                                .get_mut::<SwitcherQueue<S::Item>>(*output_signal)
-                                .unwrap()
-                                .0
-                                .extend(diffs);
-                            process_signals(world, [output_signal], Box::new(()));
+                            // The output signal may have been cleaned up during a cleanup race.
+                            if let Some(mut queue) = world.get_mut::<SwitcherQueue<S::Item>>(*output_signal) {
+                                queue.0.extend(diffs);
+                                process_signals(world, [output_signal], Box::new(()));
+                            }
                         }
                     };
 
@@ -2120,12 +2119,11 @@ pub trait SignalExt: Signal {
                     let forwarder_logic = move |In(diffs): In<Vec<super::signal_map::MapDiff<S::Key, S::Value>>>,
                                                 world: &mut World| {
                         if !diffs.is_empty() {
-                            world
-                                .get_mut::<SwitcherQueue<S::Key, S::Value>>(*output_signal)
-                                .unwrap()
-                                .0
-                                .extend(diffs);
-                            process_signals(world, [output_signal], Box::new(()));
+                            // The output signal may have been cleaned up during a cleanup race.
+                            if let Some(mut queue) = world.get_mut::<SwitcherQueue<S::Key, S::Value>>(*output_signal) {
+                                queue.0.extend(diffs);
+                                process_signals(world, [output_signal], Box::new(()));
+                            }
                         }
                     };
 

From 536b7e5a64e5a836e53d430da09f27a03638e33d Mon Sep 17 00:00:00 2001
From: databasedav <31483365+databasedav@users.noreply.github.com>
Date: Sat, 31 Jan 2026 19:12:40 -0800
Subject: [PATCH 15/15] check

---
 Cargo.lock        |    1 +
 Cargo.toml        |    1 +
 agents.md         |    5 +
 justfile          |    3 -
 repo_prompt.ncl   |   61 --
 src/builder.rs    |   68 +-
 src/graph.rs      | 1503 ++++++++++++++++++++++++++++++++++++---------
 src/lib.rs        |  153 ++++-
 src/signal.rs     |  691 +++++++++++++--------
 src/signal_map.rs |  225 ++++---
 src/signal_vec.rs |  375 ++++++-----
 src/utils.rs      |    4 -
 12 files changed, 2173 insertions(+), 917 deletions(-)
 create mode 100644 agents.md
 delete mode 100644 repo_prompt.ncl

diff --git a/Cargo.lock b/Cargo.lock
index 3df3779..745cf79 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2770,6 +2770,7 @@ dependencies = [
  "bevy",
  "bevy_app",
  "bevy_derive",
+ "bevy_diagnostic",
  "bevy_ecs",
  "bevy_log",
  "bevy_platform",
diff --git a/Cargo.toml b/Cargo.toml
index 8cd0c6f..5e4e03a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,7 @@ documentation = "https://docs.rs/jonmo"
 [dependencies]
 bevy_app = { version = "0.17", default-features = false }
 bevy_derive = { version = "0.17", default-features = false }
+bevy_diagnostic = { version = "0.17", default-features = false }
 bevy_ecs = { version = "0.17", default-features = false }
 bevy_platform = { version = "0.17", default-features = false }
 bevy_log = { version = "0.17", default-features = false, optional = true }
diff --git a/agents.md b/agents.md
new file mode 100644
index 0000000..b0b9951
--- /dev/null
+++ b/agents.md
@@ -0,0 +1,5 @@
+# Agent Instructions
+
+## Testing
+
+Use `just test` for running tests.
diff --git a/justfile b/justfile
index d5cb82b..d97645f 100644
--- a/justfile
+++ b/justfile
@@ -16,8 +16,5 @@ exclude_examples := '"test", "utils"'
 # TODO: use an actual list https://github.com/casey/just/issues/2458
 export_nickels := "ci build_example pr_previews examples_on_main cleanup_pr_previews release"
 
-repo_prompt:
-  @nickel eval repo_prompt.ncl | sed 's/^"//; s/"$//; s/\\"/"/g; s/\\n/\n/g'
-
 sync_readme_example:
   uv run python sync_readme_example.py
diff --git a/repo_prompt.ncl b/repo_prompt.ncl
deleted file mode 100644
index f4f703c..0000000
--- a/repo_prompt.ncl
+++ /dev/null
@@ -1,61 +0,0 @@
-let src_lib = import "src/lib.rs" as 'Text in
-let src_builder = import "src/builder.rs" as 'Text in
-let src_signal_vec = import "src/signal_vec.rs" as 'Text in
-let src_signal = import "src/signal.rs" as 'Text in
-let src_signal_map = import "src/signal_map.rs" as 'Text in
-let src_graph = import "src/graph.rs" as 'Text in
-let src_utils = import "src/utils.rs" as 'Text in
-let examples_basic_builder = import "examples/basic_builder.rs" as 'Text in
-let examples_basic_builder_inject = import "examples/basic_builder_inject.rs" as 'Text in
-let examples_basic = import "examples/basic.rs" as 'Text in
-let examples_lifetimes = import "examples/lifetimes.rs" as 'Text in
-let examples_filters = import "examples/filters.rs" as 'Text in
-let examples_counter = import "examples/counter.rs" as 'Text in
-let examples_letters = import "examples/letters.rs" as 'Text in
-let examples_test = import "examples/test.rs" as 'Text in
-let examples_utils = import "examples/utils.rs" as 'Text in
-let repo_structure = {
-  "src/lib.rs" = src_lib,
-  "src/builder.rs" = src_builder,
-  "src/signal_vec.rs" = src_signal_vec,
-  "src/signal.rs" = src_signal,
-  "src/signal_map.rs" = src_signal_map,
-  "src/graph.rs" = src_graph,
-  "src/utils.rs" = src_utils,
-  "examples/basic_builder.rs" = examples_basic_builder,
-  "examples/basic.rs" = examples_basic,
-  "examples/lifetimes.rs" = examples_lifetimes,
-  "examples/filters.rs" = examples_filters,
-  "examples/counter.rs" = examples_counter,
-  "examples/letters.rs" = examples_letters,
-  "examples/test.rs" = examples_test,
-  "examples/utils.rs" = examples_utils,
-} in
-let prompt = import "repo_prompt_input.md" as 'Text in
-
-m%"
-%{ prompt }
-
-jonmo is a functional reactive signals implementation in rust for the bevy game engine; here is the structure of the jonmo repository with the contents of each file:
-.
-├── examples/
-│   ├── basic_builder.rs
-│   ├── basic.rs
-│   ├── basic_builder_inject.rs
-│   ├── counter.rs
-│   ├── lifetimes.rs
-│   ├── filters.rs
-│   ├── letters.rs
-│   ├── test.rs
-│   └── utils.rs
-└── src/
-    ├── builder.rs
-    ├── lib.rs
-    ├── signal_vec.rs
-    ├── signal.rs
-    ├── signal_map.rs
-    ├── graph.rs
-    └── utils.rs
-
-%{ repo_structure |> std.record.map (fun k v => "%{ k }\n```rust\n%{ v }\n```") |> std.record.values |> std.string.join "\n\n" }
-"%
diff --git a/src/builder.rs b/src/builder.rs
index 1d96654..7e8abb1 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -4,7 +4,7 @@ use super::{
     signal::{Signal, SignalExt},
     signal_map::{SignalMap, SignalMapExt},
     signal_vec::{SignalVec, SignalVecExt, VecDiff},
-    utils::{LazyEntity, SSs},
+    utils::LazyEntity,
 };
 use bevy_ecs::{
     component::Mutable,
@@ -73,7 +73,14 @@ impl Clone for Builder {
             core::panic::Location::caller()
         );
         if cfg!(debug_assertions) {
-            panic!("{}", msg);
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "std")] {
+                    let backtrace = std::backtrace::Backtrace::force_capture();
+                    panic!("{}\nBacktrace:\n{}", msg, backtrace);
+                } else {
+                    panic!("{}", msg);
+                }
+            }
         }
         #[cfg(feature = "tracing")]
         bevy_log::error!("{}", msg);
@@ -109,7 +116,7 @@ impl Builder {
     }
 
     /// Run a function with mutable access to the [`World`] and this builder's [`Entity`].
-    pub fn on_spawn(mut self, on_spawn: impl FnOnce(&mut World, Entity) + SSs) -> Self {
+    pub fn on_spawn(mut self, on_spawn: impl FnOnce(&mut World, Entity) + Send + Sync + 'static) -> Self {
         self.on_spawns.push(Box::new(on_spawn));
         self
     }
@@ -117,7 +124,7 @@ impl Builder {
     /// Run a [`System`] which takes [`In`] this builder's [`Entity`].
     pub fn on_spawn_with_system<T, M>(self, system: T) -> Self
     where
-        T: IntoSystem<In<Entity>, (), M> + SSs,
+        T: IntoSystem<In<Entity>, (), M> + Send + Sync + 'static,
     {
         self.on_spawn(|world, entity| {
             #[allow(unused_variables)]
@@ -157,7 +164,7 @@ impl Builder {
     ///
     /// jonmo::Builder::new().hold_tasks([my_signal_task, my_signal_vec_task]);
     /// ```
-    pub fn hold_tasks(self, tasks: impl IntoIterator<Item = Box<dyn SignalTask>> + SSs) -> Self {
+    pub fn hold_tasks(self, tasks: impl IntoIterator<Item = Box<dyn SignalTask>> + Send + Sync + 'static) -> Self {
         self.on_spawn(move |world, entity| {
             let handles: Vec<_> = tasks.into_iter().map(|task| task.register_task(world)).collect();
             add_handles(world, entity, handles);
@@ -165,7 +172,7 @@ impl Builder {
     }
 
     /// Run a function with this builder's [`EntityWorldMut`].
-    pub fn with_entity(self, f: impl FnOnce(EntityWorldMut) + SSs) -> Self {
+    pub fn with_entity(self, f: impl FnOnce(EntityWorldMut) + Send + Sync + 'static) -> Self {
         self.on_spawn(move |world, entity| {
             f(world.entity_mut(entity));
         })
@@ -180,7 +187,10 @@ impl Builder {
 
     /// Run a function with mutable access (via [`Mut`]) to this builder's `C` [`Component`] if it
     /// exists.
-    pub fn with_component<C: Component<Mutability = Mutable>>(self, f: impl FnOnce(Mut<C>) + SSs) -> Self {
+    pub fn with_component<C: Component<Mutability = Mutable>>(
+        self,
+        f: impl FnOnce(Mut<C>) + Send + Sync + 'static,
+    ) -> Self {
         self.with_entity(|mut entity| {
             if let Some(component) = entity.get_mut::<C>() {
                 f(component);
@@ -223,9 +233,9 @@ impl Builder {
     /// The `signal` will be automatically cleaned up when the [`Entity`] is despawned.
     pub fn on_signal<I, S, F, M>(self, signal: S, system: F) -> Self
     where
-        I: Clone + 'static,
-        S: Signal<Item = I> + SSs,
-        F: IntoSystem<In<(Entity, I)>, (), M> + SSs,
+        I: Clone + Send + Sync + 'static,
+        S: Signal<Item = I> + Send + Sync + 'static,
+        F: IntoSystem<In<(Entity, I)>, (), M> + Send + Sync + 'static,
     {
         let on_spawn = move |world: &mut World, entity: Entity| {
             let handle =
@@ -241,9 +251,9 @@ impl Builder {
     /// The `signal` will be automatically cleaned up when the [`Entity`] is despawned.
     pub fn on_signal_with_entity<I, S, F>(self, signal: S, mut f: F) -> Self
     where
-        I: Clone + 'static,
-        S: Signal<Item = I> + SSs,
-        F: FnMut(EntityWorldMut, I) + SSs,
+        I: Clone + Send + Sync + 'static,
+        S: Signal<Item = I> + Send + Sync + 'static,
+        F: FnMut(EntityWorldMut, I) + Send + Sync + 'static,
     {
         self.on_signal(signal, move |In((entity, value)), world: &mut World| {
             f(world.entity_mut(entity), value)
@@ -254,12 +264,14 @@ impl Builder {
     /// `C` [`Component`] if it exists and the output of a [`Signal`].
     ///
     /// The `signal` will be automatically cleaned up when the [`Entity`] is despawned.
-    pub fn on_signal_with_component<C, I, S, F>(self, signal: S, mut f: F) -> Self
+    pub fn on_signal_with_component<I, C>(
+        self,
+        signal: impl Signal<Item = I>,
+        mut f: impl FnMut(Mut<C>, I) + Send + Sync + 'static,
+    ) -> Self
     where
         C: Component<Mutability = Mutable>,
         I: Clone + 'static,
-        S: Signal<Item = I> + SSs,
-        F: FnMut(Mut<C>, I) + SSs,
     {
         let on_spawn = move |world: &mut World, entity: Entity| {
             let handle = Signal::register_signal(
@@ -277,10 +289,9 @@ impl Builder {
 
     /// Reactively set this builder's [`Entity`]'s `C` [`Component`] with a [`Signal`] that outputs
     /// an [`Option`]al `C`; if the [`Signal`] outputs [`None`], the `C` [`Component`] is removed.
-    pub fn component_signal<C, S>(self, signal: S) -> Self
+    pub fn component_signal<C>(self, signal: impl Signal<Item = Option<C>>) -> Self
     where
         C: Component + Clone,
-        S: Signal<Item = Option<C>> + SSs,
     {
         self.on_signal(
             signal,
@@ -491,7 +502,8 @@ impl Builder {
     ///
     /// # Errors
     ///
-    /// Returns an error if the entity does not exist in the world.
+    /// Returns [`EntityMutableFetchError::EntityDoesNotExist`] if the entity does not exist in the
+    /// world.
     pub fn spawn_on_entity(self, world: &mut World, entity: Entity) -> Result<(), EntityMutableFetchError> {
         let mut entity_mut = world.get_entity_mut(entity)?;
         let id = entity_mut.id();
@@ -524,14 +536,14 @@ pub trait SignalTask: Send + Sync + 'static {
 
 struct SignalTaskSignal<S>(S);
 
-impl<S: Signal + SSs> SignalTask for SignalTaskSignal<S> {
+impl<S: Signal + Send + Sync + 'static> SignalTask for SignalTaskSignal<S> {
     fn register_task(self: Box<Self>, world: &mut World) -> SignalHandle {
         self.0.register(world)
     }
 }
 
 /// Extension trait for converting a [`Signal`] into a [`SignalTask`].
-pub trait SignalTaskExt: Signal + Sized + SSs {
+pub trait SignalTaskExt: Signal + Sized + Send + Sync + 'static {
     /// Convert this signal into a type-erased [`SignalTask`] for use with
     /// [`Builder::hold_tasks`].
     fn task(self) -> Box<dyn SignalTask> {
@@ -539,18 +551,18 @@ pub trait SignalTaskExt: Signal + Sized + SSs {
     }
 }
 
-impl<S: Signal + Sized + SSs> SignalTaskExt for S {}
+impl<S: Signal + Sized + Send + Sync + 'static> SignalTaskExt for S {}
 
 struct SignalTaskSignalVec<S>(S);
 
-impl<S: SignalVec + SSs> SignalTask for SignalTaskSignalVec<S> {
+impl<S: SignalVec + Send + Sync + 'static> SignalTask for SignalTaskSignalVec<S> {
     fn register_task(self: Box<Self>, world: &mut World) -> SignalHandle {
         self.0.register(world)
     }
 }
 
 /// Extension trait for converting a [`SignalVec`] into a [`SignalTask`].
-pub trait SignalVecTaskExt: SignalVec + Sized + SSs {
+pub trait SignalVecTaskExt: SignalVec + Sized + Send + Sync + 'static {
     /// Convert this signal vec into a type-erased [`SignalTask`] for use with
     /// [`Builder::hold_tasks`].
     fn task(self) -> Box<dyn SignalTask> {
@@ -558,18 +570,18 @@ pub trait SignalVecTaskExt: SignalVec + Sized + SSs {
     }
 }
 
-impl<S: SignalVec + Sized + SSs> SignalVecTaskExt for S {}
+impl<S: SignalVec + Sized + Send + Sync + 'static> SignalVecTaskExt for S {}
 
 struct SignalTaskSignalMap<S>(S);
 
-impl<S: SignalMap + SSs> SignalTask for SignalTaskSignalMap<S> {
+impl<S: SignalMap + Send + Sync + 'static> SignalTask for SignalTaskSignalMap<S> {
     fn register_task(self: Box<Self>, world: &mut World) -> SignalHandle {
         self.0.register(world)
     }
 }
 
 /// Extension trait for converting a [`SignalMap`] into a [`SignalTask`].
-pub trait SignalMapTaskExt: SignalMap + Sized + SSs {
+pub trait SignalMapTaskExt: SignalMap + Sized + Send + Sync + 'static {
     /// Convert this signal map into a type-erased [`SignalTask`] for use with
     /// [`Builder::hold_tasks`].
     fn task(self) -> Box<dyn SignalTask> {
@@ -577,7 +589,7 @@ pub trait SignalMapTaskExt: SignalMap + Sized + SSs {
     }
 }
 
-impl<S: SignalMap + Sized + SSs> SignalMapTaskExt for S {}
+impl<S: SignalMap + Sized + Send + Sync + 'static> SignalMapTaskExt for S {}
 
 fn on_despawn_hook(mut world: DeferredWorld, ctx: HookContext) {
     let entity = ctx.entity;
diff --git a/src/graph.rs b/src/graph.rs
index df59595..547b94f 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -1,12 +1,74 @@
 //! Signal graph management and runtime.
-use super::utils::SSs;
+//!
+//! This module contains the core infrastructure for [jonmo](crate)'s reactive signal graph,
+//! including graph topology tracking, signal registration, multi-schedule processing, and
+//! the per-frame processing loop.
+//!
+//! # Graph Structure
+//!
+//! The signal graph is a directed acyclic graph (DAG) where each node is backed by a Bevy
+//! [`System`]. Edges represent data dependencies: when an upstream signal produces output, that
+//! output becomes the input to its downstream signals. Cycles are detected and rejected at
+//! edge-creation time.
+//!
+//! # Multi-Schedule Processing
+//!
+//! Signals can be assigned to run in different Bevy schedules (e.g., `Update`, `PostUpdate`)
+//! using [`SignalExt::schedule`](super::signal::SignalExt::schedule). This enables fine-grained
+//! control over when signals execute within each frame.
+//!
+//! - **Schedule assignment**: Each signal can be assigned to a specific schedule. Unassigned
+//!   signals inherit the schedule from upstream signals or default to the
+//!   [`JonmoPlugin`](crate::JonmoPlugin)'s default schedule, see
+//!   [`SignalExt::schedule`](super::signal::SignalExt::schedule) for the exact semantics.
+//! - **Cross-schedule data flow**: Signals in different schedules can still be connected. Outputs
+//!   from earlier schedules are available as inputs to signals in later schedules.
+//! - **Per-schedule graph partitioning**: The graph is partitioned by schedule, with each schedule
+//!   processing only its assigned signals in topological order.
+//!
+//! # Processing Semantics
+//!
+//! Each frame, within each configured schedule, signals are processed in topological order:
+//!
+//! 1. **Level assignment**: Each signal is assigned a level equal to 1 + the maximum level of its
+//!    upstreams (roots have level 0). This is recomputed incrementally when edges change.
+//! 2. **Level-order execution**: Signals are processed level by level, lowest first, ensuring every
+//!    signal's upstreams have already run before it executes. Within each level, signals are
+//!    processed in deterministic order (sorted by entity index) for reproducible behavior.
+//! 3. **Output forwarding**: When a signal produces [`Some`] value, that value is forwarded as
+//!    input to all downstream signals. Returning [`None`] terminates propagation for that branch.
+//! 4. **Dynamic registration**: Signals registered during processing (e.g., from UI element
+//!    spawning) are integrated and processed within the same frame, avoiding one-frame delays.
+//!
+//! A signal with multiple upstreams runs **once per upstream** that fires in a given frame. This
+//! allows a signal to act as a collection point, processing each upstream's output in turn.
+//! However, only the **final output** (from the last run) is forwarded to downstream signals,
+//! ensuring that downstreams see a single, consolidated result rather than receiving multiple
+//! inputs.
+//!
+//! # Lifecycle
+//!
+//! Signal systems are usage-tracked; each call to [`.register`](super::signal::SignalExt::register)
+//! increments a registration count on the signal and its upstreams. To release a signal,
+//! [`SignalHandle::cleanup`] must be called, either explicitly or implicitly by storing handles in
+//! a [`SignalHandles`] component (which calls cleanup when the entity is despawned). When a
+//! signal's registration count reaches zero and no downstream dependents remain, the signal's
+//! backing system is automatically despawned.
+//!
+//! # Polling
+//!
+//! In addition to the standard push-based flow, signals can be polled synchronously to retrieve
+//! their most recent output. This is useful when a system needs to read signal state on-demand
+//! rather than receiving it as pushed input.
 use alloc::collections::VecDeque;
+use bevy_app::PostUpdate;
 use bevy_derive::Deref;
 use bevy_ecs::{
     entity_disabling::Internal,
     lifecycle::HookContext,
     prelude::*,
     query::{QueryData, QueryFilter},
+    schedule::{InternedScheduleLabel, ScheduleLabel},
     system::{SystemId, SystemState},
     world::DeferredWorld,
 };
@@ -54,12 +116,74 @@ impl SignalRegistrationCount {
     }
 }
 
+/// Component on signal system entities indicating which schedule they run in.
+///
+/// Used by the multi-schedule processing system to determine which signals
+/// to run during each schedule's processing pass.
+#[derive(Component, Clone, Copy)]
+pub(crate) struct SignalScheduleTag(pub(crate) InternedScheduleLabel);
+
+/// Component for downstream schedule inheritance during registration.
+///
+/// When a signal is connected to an upstream via [`pipe_signal`], if the upstream
+/// has a `ScheduleHint`, the downstream inherits the schedule (unless it already
+/// has a [`SignalScheduleTag`]).
+#[derive(Component, Clone, Copy)]
+pub(crate) struct ScheduleHint(pub(crate) InternedScheduleLabel);
+
+/// Apply schedule tagging to a signal: tag the signal itself, propagate to unscheduled
+/// upstreams, and set hint for downstream inheritance.
+///
+/// This is the common logic used by [`SignalExt::schedule`](super::signal::SignalExt::schedule),
+/// [`SignalVecExt::schedule`](super::signal_vec::SignalVecExt::schedule), and
+/// [`SignalMapExt::schedule`](super::signal_map::SignalMapExt::schedule).
+pub(crate) fn apply_schedule_to_signal(world: &mut World, signal: SignalSystem, schedule: InternedScheduleLabel) {
+    // Directly tag caller (overwrites any inherited schedule)
+    world.entity_mut(*signal).insert(SignalScheduleTag(schedule));
+
+    // Propagate to unscheduled upstreams
+    tag_unscheduled_upstreams(world, signal, schedule);
+
+    // Set hint for downstream inheritance
+    world.entity_mut(*signal).insert(ScheduleHint(schedule));
+}
+
+/// Tags all upstream signals that don't already have a [`SignalScheduleTag`].
+///
+/// Traverses the upstream graph from `start` and applies the given `schedule` to any
+/// signal that hasn't been explicitly scheduled. This ensures that when a downstream
+/// signal is scheduled, its entire upstream chain runs in a compatible schedule.
+pub(crate) fn tag_unscheduled_upstreams(world: &mut World, start: SignalSystem, schedule: InternedScheduleLabel) {
+    let mut stack = vec![start];
+    let mut visited = HashSet::new();
+
+    while let Some(current) = stack.pop() {
+        if !visited.insert(current) {
+            continue;
+        }
+
+        // Tag if not already tagged
+        if world.get::<SignalScheduleTag>(*current).is_none() {
+            world.entity_mut(*current).insert(SignalScheduleTag(schedule));
+        }
+
+        // Continue to upstreams
+        if let Some(upstream) = world.get::<Upstream>(*current) {
+            for &up in upstream.iter() {
+                if !visited.contains(&up) {
+                    stack.push(up);
+                }
+            }
+        }
+    }
+}
+
 pub(crate) fn register_signal<I, O, IOO, F, M>(world: &mut World, system: F) -> SignalSystem
 where
     I: 'static,
-    O: Clone + 'static,
+    O: Clone + Send + Sync + 'static,
     IOO: Into<Option<O>> + 'static,
-    F: IntoSystem<In<I>, IOO, M> + SSs,
+    F: IntoSystem<In<I>, IOO, M> + Send + Sync + 'static,
 {
     lazy_signal_from_system(system).register(world)
 }
@@ -131,6 +255,17 @@ pub(crate) fn pipe_signal(world: &mut World, source: SignalSystem, target: Signa
     } else {
         downstream.insert(Upstream(HashSet::from([source])));
     }
+
+    // Inherit schedule from upstream if target doesn't already have one
+    if world.get::<SignalScheduleTag>(*target).is_none()
+        && let Some(hint) = world.get::<ScheduleHint>(*source).copied()
+    {
+        world
+            .entity_mut(*target)
+            .insert(SignalScheduleTag(hint.0))
+            .insert(ScheduleHint(hint.0)); // Pass it on to further downstreams
+    }
+
     world
         .resource_mut::<SignalGraphState>()
         .edge_change_seeds
@@ -160,7 +295,7 @@ where
 impl<I, O, S> Runnable for SystemHolder<I, O, S>
 where
     I: 'static,
-    O: Clone,
+    O: Clone + Send + Sync,
     S: Into<Option<O>> + 'static,
 {
     fn run(&self, world: &mut World, input: Box<dyn Any>) -> Option<Box<dyn AnyClone>> {
@@ -192,52 +327,121 @@ impl SystemRunner {
     }
 }
 
-/// An extension trait for [`Any`] types that implement [`Clone`].
-pub trait AnyClone: Any + DynClone {}
+/// An extension trait for [`Any`] types that implement [`Clone`], [`Send`], and [`Sync`].
+pub trait AnyClone: Any + DynClone + Send + Sync {}
 
 clone_trait_object!(AnyClone);
 
-impl<T: Clone + 'static> AnyClone for T {}
+impl<T: Clone + Send + Sync + 'static> AnyClone for T {}
+
+/// Component that stores pending inputs for a signal.
+///
+/// Inputs are written by upstream signals and read by the signal during processing.
+/// The buffer is cleared at the end of each frame.
+#[derive(Component, Default)]
+pub(crate) struct SignalInputBuffer(pub(crate) Vec<Box<dyn AnyClone>>);
+
+impl SignalInputBuffer {
+    /// Take all inputs, leaving the buffer empty.
+    fn take(&mut self) -> Vec<Box<dyn AnyClone>> {
+        core::mem::take(&mut self.0)
+    }
+
+    /// Push an input value.
+    fn push(&mut self, value: Box<dyn AnyClone>) {
+        self.0.push(value);
+    }
+
+    /// Clear the buffer.
+    fn clear(&mut self) {
+        self.0.clear();
+    }
+}
+
+/// Behavior when the signal registration recursion limit is exceeded.
+///
+/// During signal processing, signals can spawn new signals (e.g., UI elements registering
+/// child signals). These new signals are processed in the same frame via recursive passes.
+/// If signals keep spawning more signals indefinitely, this limit prevents infinite loops.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum RecursionLimitBehavior {
+    /// Panic with an error message. This is the default because hitting the limit
+    /// almost always indicates a bug (infinite signal spawning loop).
+    #[default]
+    Panic,
+    /// Log a warning (if the `tracing` feature is enabled) and stop processing
+    /// new signals for this frame. The graph may be left in an incomplete state.
+    Warn,
+    /// Silently stop processing new signals. Use this only if you understand the
+    /// implications and have a specific reason to suppress the error.
+    Silent,
+}
 
 /// Tracks signal graph topology for level-based processing.
-#[derive(Resource, Default)]
+#[derive(Resource)]
 pub(crate) struct SignalGraphState {
     /// Cached level for each signal (max distance from any root).
     levels: HashMap<SignalSystem, u32>,
-    /// Signals grouped by level for efficient iteration.
-    by_level: Vec<Vec<SignalSystem>>,
+    /// Signals partitioned by schedule for efficient per-schedule iteration.
+    /// Updated incrementally alongside level updates.
+    by_schedule: HashMap<InternedScheduleLabel, Vec<Vec<SignalSystem>>>,
+    /// Cache of which schedule each signal belongs to, for O(1) lookup during removal.
+    signal_schedules: HashMap<SignalSystem, InternedScheduleLabel>,
     /// Signals that seed level recomputation after edge changes.
     edge_change_seeds: HashSet<SignalSystem>,
     /// Signals queued for removal while the graph is being processed.
     deferred_removals: HashSet<SignalSystem>,
     /// Whether the signal graph is currently being processed.
     is_processing: bool,
+    /// Default schedule for signals without explicit scheduling.
+    default_schedule: InternedScheduleLabel,
+    /// Maximum number of recursive signal registration passes per frame.
+    registration_recursion_limit: usize,
+    /// What to do when the recursion limit is exceeded.
+    on_recursion_limit_exceeded: RecursionLimitBehavior,
 }
 
-// Fan out a signal output to downstream input queues. When there is exactly one downstream, move
-// the value without cloning.
-fn enqueue_inputs(
-    world: &World,
-    inputs: &mut HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>>,
-    signal: SignalSystem,
-    value: Box<dyn AnyClone>,
-) {
-    let downstreams = get_downstreams(world, signal);
-    if downstreams.is_empty() {
-        return;
-    }
+/// Default recursion limit for signal registration passes.
+pub const DEFAULT_REGISTRATION_RECURSION_LIMIT: usize = 100;
 
-    if downstreams.len() == 1 {
-        // avoid cloning if there's only a single downstream
-        inputs.entry(downstreams[0]).or_default().push_back(value);
-        return;
+impl Default for SignalGraphState {
+    fn default() -> Self {
+        Self::with_options(
+            PostUpdate.intern(),
+            DEFAULT_REGISTRATION_RECURSION_LIMIT,
+            RecursionLimitBehavior::default(),
+        )
     }
+}
 
-    if let Some((last, rest)) = downstreams.split_last() {
-        for downstream in rest {
-            inputs.entry(*downstream).or_default().push_back(value.clone());
+impl SignalGraphState {
+    /// Create a new SignalGraphState with the specified default schedule.
+    #[allow(unused)] // used in tests
+    pub(crate) fn new(default_schedule: InternedScheduleLabel) -> Self {
+        Self::with_options(
+            default_schedule,
+            DEFAULT_REGISTRATION_RECURSION_LIMIT,
+            RecursionLimitBehavior::default(),
+        )
+    }
+
+    /// Create a new SignalGraphState with full configuration options.
+    pub(crate) fn with_options(
+        default_schedule: InternedScheduleLabel,
+        registration_recursion_limit: usize,
+        on_recursion_limit_exceeded: RecursionLimitBehavior,
+    ) -> Self {
+        Self {
+            levels: HashMap::default(),
+            by_schedule: HashMap::default(),
+            signal_schedules: HashMap::default(),
+            edge_change_seeds: HashSet::default(),
+            deferred_removals: HashSet::default(),
+            is_processing: false,
+            default_schedule,
+            registration_recursion_limit,
+            on_recursion_limit_exceeded,
         }
-        inputs.entry(*last).or_default().push_back(value);
     }
 }
 
@@ -264,236 +468,316 @@ fn insert_sorted_by_index(bucket: &mut Vec<SignalSystem>, signal: SignalSystem)
     bucket.insert(index, signal);
 }
 
-// Computes a per-call, local topological ordering of signals reachable downstream
-// from `seeds`. This intentionally does NOT use `SignalGraphState` because it only
-// needs a lightweight traversal for the provided subset and should not mutate or
-// depend on the global cached topology.
-fn downstream_levels_from_seeds(world: &World, seeds: &[SignalSystem]) -> Vec<Vec<SignalSystem>> {
-    let mut levels: HashMap<SignalSystem, u32> = HashMap::new();
-    let mut by_level: Vec<HashSet<SignalSystem>> = Vec::new();
-    let mut queue: VecDeque<SignalSystem> = VecDeque::new();
-
-    for signal in seeds {
-        levels.insert(*signal, 0);
-        queue.push_back(*signal);
-    }
-
-    while let Some(signal) = queue.pop_front() {
-        let level = *levels.get(&signal).unwrap_or(&0);
-        for downstream in get_downstreams(world, signal) {
-            let next_level = level.saturating_add(1);
-            let current = levels.get(&downstream).copied().unwrap_or(0);
-            if next_level > current {
-                levels.insert(downstream, next_level);
-                queue.push_back(downstream);
-            }
-        }
-    }
+/// Result of computing signal levels via Kahn's algorithm.
+struct LevelComputeResult {
+    /// Computed levels for each signal in the working set.
+    levels: HashMap<SignalSystem, u32>,
+    /// Number of signals successfully processed.
+    processed: usize,
+    /// Total number of signals in the working set.
+    total: usize,
+}
 
-    for (signal, level) in levels.iter() {
-        while by_level.len() <= *level as usize {
-            by_level.push(HashSet::new());
-        }
-        by_level[*level as usize].insert(*signal);
+impl LevelComputeResult {
+    fn is_complete(&self) -> bool {
+        self.processed == self.total
     }
-
-    by_level
-        .into_iter()
-        .map(|level| {
-            let mut signals_at_level: Vec<SignalSystem> = level.into_iter().collect();
-            // Sort by Entity index to get a deterministic, stable order independent of hash iteration.
-            signals_at_level.sort_by_key(|signal| signal.index());
-            signals_at_level
-        })
-        .collect()
 }
 
-// Rebuilds per-signal levels using a Kahn-style topological traversal.
-//
-// - Roots (in-degree 0) start at level 0.
-// - Each node's level is 1 + max(level of its upstreams).
-// - Nodes are bucketed by level for deterministic per-level iteration.
-// - If a cycle or inconsistent edges are detected (not all nodes processed), this panics because
-//   the graph invariants were violated.
-fn rebuild_levels(world: &mut World, state: &mut SignalGraphState) {
-    state.levels.clear();
-    state.by_level.clear();
-
-    let mut all_signals = SystemState::<Query<Entity, (With<SystemRunner>, Allow<Internal>)>>::new(world);
-    let signals = all_signals.get(world).iter().map(SignalSystem).collect::<Vec<_>>();
+/// Core Kahn's algorithm for computing topological levels on a subset of signals.
+///
+/// - `signals`: the working set of signals to compute levels for
+/// - `upstream_filter`: determines which upstreams count toward in-degree (typically the working
+///   set)
+/// - `external_level`: provides levels for upstreams outside the working set
+fn compute_signal_levels(
+    world: &World,
+    signals: &HashSet<SignalSystem>,
+    upstream_filter: impl Fn(SignalSystem) -> bool,
+    external_level: impl Fn(SignalSystem) -> Option<u32>,
+) -> LevelComputeResult {
+    if signals.is_empty() {
+        return LevelComputeResult {
+            levels: HashMap::new(),
+            processed: 0,
+            total: 0,
+        };
+    }
 
     let mut in_degree: HashMap<SignalSystem, usize> = HashMap::new();
     let mut upstreams_map: HashMap<SignalSystem, Vec<SignalSystem>> = HashMap::new();
     let mut downstreams_map: HashMap<SignalSystem, Vec<SignalSystem>> = HashMap::new();
 
-    for signal in signals {
+    for &signal in signals {
         let upstreams = get_upstreams(world, signal);
-        in_degree.insert(signal, upstreams.len());
-        upstreams_map.insert(signal, upstreams.clone());
-        for upstream in upstreams {
+        let local_in_degree = upstreams.iter().filter(|u| upstream_filter(**u)).count();
+        in_degree.insert(signal, local_in_degree);
+        // Build local downstreams_map by inverting upstream relationships.
+        // This ensures we only traverse to signals in our working set.
+        for &upstream in upstreams.iter().filter(|u| signals.contains(*u)) {
             downstreams_map.entry(upstream).or_default().push(signal);
         }
+        upstreams_map.insert(signal, upstreams);
     }
 
-    let mut queue: VecDeque<SignalSystem> = in_degree
-        .iter()
-        .filter_map(|(signal, degree)| if *degree == 0 { Some(*signal) } else { None })
-        .collect();
+    let mut queue: VecDeque<SignalSystem> = in_degree.iter().filter_map(|(s, d)| (*d == 0).then_some(*s)).collect();
 
+    let mut levels: HashMap<SignalSystem, u32> = HashMap::new();
     let mut processed = 0usize;
+
     while let Some(signal) = queue.pop_front() {
         processed += 1;
         let upstreams = upstreams_map.get(&signal).cloned().unwrap_or_default();
-        let level = if upstreams.is_empty() {
-            0
-        } else {
-            upstreams
-                .iter()
-                .filter_map(|u| state.levels.get(u))
-                .max()
-                .map(|m| m + 1)
-                .unwrap_or(0)
-        };
+        let level = upstreams
+            .iter()
+            .filter_map(|u| levels.get(u).copied().or_else(|| external_level(*u)))
+            .max()
+            .map(|m| m + 1)
+            .unwrap_or(0);
 
-        while state.by_level.len() <= level as usize {
-            state.by_level.push(Vec::new());
-        }
-        state.by_level[level as usize].push(signal);
-        state.levels.insert(signal, level);
+        levels.insert(signal, level);
 
+        // Use local downstreams_map instead of get_downstreams to ensure we only
+        // consider signals in our working set.
         if let Some(downstreams) = downstreams_map.get(&signal) {
-            for downstream in downstreams {
-                if let Some(count) = in_degree.get_mut(downstream) {
+            for &downstream in downstreams {
+                if let Some(count) = in_degree.get_mut(&downstream) {
                     *count = count.saturating_sub(1);
                     if *count == 0 {
-                        queue.push_back(*downstream);
+                        queue.push_back(downstream);
                     }
                 }
             }
         }
     }
 
-    if processed < in_degree.len() {
-        panic!("signal graph contains a cycle or inconsistent edges during level rebuild");
+    LevelComputeResult {
+        levels,
+        processed,
+        total: signals.len(),
     }
+}
 
-    for bucket in state.by_level.iter_mut() {
-        bucket.sort_by_key(|signal| signal.index());
+fn bucket_levels_sorted(levels: &HashMap<SignalSystem, u32>) -> Vec<Vec<SignalSystem>> {
+    let mut by_level: Vec<Vec<SignalSystem>> = Vec::new();
+    for (&signal, &level) in levels {
+        while by_level.len() <= level as usize {
+            by_level.push(Vec::new());
+        }
+        by_level[level as usize].push(signal);
+    }
+    for bucket in &mut by_level {
+        bucket.sort_by_key(|s| s.index());
     }
+    by_level
 }
 
-fn update_levels_incremental(world: &mut World, state: &mut SignalGraphState) -> bool {
-    let mut affected: HashSet<SignalSystem> = HashSet::new();
-    let mut queue: VecDeque<SignalSystem> = state.edge_change_seeds.iter().copied().collect();
+// Computes a topological ordering of signals reachable downstream from `seeds`.
+// Uses cached levels when available, falls back to BFS level computation for uncached signals.
+fn downstream_levels_from_seeds(world: &World, seeds: &[SignalSystem]) -> Vec<Vec<SignalSystem>> {
+    let state = world.resource::<SignalGraphState>();
 
+    // Collect all reachable signals via BFS.
+    let mut reachable: HashSet<SignalSystem> = HashSet::new();
+    let mut queue: VecDeque<SignalSystem> = seeds.iter().copied().collect();
     while let Some(signal) = queue.pop_front() {
-        if affected.insert(signal) {
-            for downstream in get_downstreams(world, signal) {
-                queue.push_back(downstream);
-            }
+        if reachable.insert(signal) {
+            queue.extend(get_downstreams(world, signal));
         }
     }
-    if affected.is_empty() {
-        return true;
+
+    // Check if all reachable signals have cached levels.
+    let all_cached = reachable.iter().all(|s| state.levels.contains_key(s));
+
+    if all_cached {
+        // Fast path: use cached levels.
+        let mut by_level: Vec<Vec<SignalSystem>> = Vec::new();
+        for signal in reachable {
+            let level = state.levels.get(&signal).copied().unwrap_or(0) as usize;
+            while by_level.len() <= level {
+                by_level.push(Vec::new());
+            }
+            by_level[level].push(signal);
+        }
+        for bucket in &mut by_level {
+            bucket.sort_by_key(|s| s.index());
+        }
+        by_level
+    } else {
+        // Slow path: compute levels via Kahn's algorithm on the reachable subgraph.
+        // This handles newly created signals that aren't in the cache yet.
+        let result = compute_signal_levels(
+            world,
+            &reachable,
+            |u| reachable.contains(&u),        // only count upstreams in the subgraph
+            |u| state.levels.get(&u).copied(), // use cached levels for external upstreams
+        );
+        bucket_levels_sorted(&result.levels)
     }
+}
 
-    let mut in_degree: HashMap<SignalSystem, usize> = HashMap::new();
-    let mut upstreams_map: HashMap<SignalSystem, Vec<SignalSystem>> = HashMap::new();
+// Rebuilds per-signal levels using a Kahn-style topological traversal.
+//
+// - Roots (in-degree 0) start at level 0.
+// - Each node's level is 1 + max(level of its upstreams).
+// - Nodes are bucketed by level for deterministic per-level iteration.
+// - If a cycle or inconsistent edges are detected (not all nodes processed), this panics because
+//   the graph invariants were violated.
+fn rebuild_levels(world: &mut World, state: &mut SignalGraphState) {
+    state.levels.clear();
+    state.by_schedule.clear();
+    state.signal_schedules.clear();
 
-    for signal in affected.iter().copied() {
-        let upstreams = get_upstreams(world, signal);
-        let local_in_degree = upstreams.iter().filter(|u| affected.contains(&(**u))).count();
-        in_degree.insert(signal, local_in_degree);
-        upstreams_map.insert(signal, upstreams);
+    let mut all_signals_state = SystemState::<Query<Entity, (With<SystemRunner>, Allow<Internal>)>>::new(world);
+    let all_signals: HashSet<SignalSystem> = all_signals_state.get(world).iter().map(SignalSystem).collect();
+
+    let result = compute_signal_levels(
+        world,
+        &all_signals,
+        |u| all_signals.contains(&u), // all upstreams count
+        |_| None,                     // no external levels
+    );
+
+    if !result.is_complete() {
+        panic!("signal graph contains a cycle or inconsistent edges during level rebuild");
     }
 
-    let mut queue: VecDeque<SignalSystem> = in_degree
-        .iter()
-        .filter_map(|(signal, degree)| if *degree == 0 { Some(*signal) } else { None })
-        .collect();
+    state.levels = result.levels;
 
-    let mut new_levels: HashMap<SignalSystem, u32> = HashMap::new();
-    let mut processed = 0usize;
+    // Build by_schedule partitioning and signal_schedules cache
+    for (&signal, &level) in &state.levels {
+        let schedule = world
+            .get::<SignalScheduleTag>(*signal)
+            .map(|tag| tag.0)
+            .unwrap_or(state.default_schedule);
 
-    while let Some(signal) = queue.pop_front() {
-        processed += 1;
-        let upstreams = upstreams_map.get(&signal).cloned().unwrap_or_default();
+        // Cache the schedule for O(1) lookup during removal
+        state.signal_schedules.insert(signal, schedule);
 
-        let mut level = 0u32;
-        for upstream in upstreams {
-            let upstream_level = new_levels
-                .get(&upstream)
-                .copied()
-                .or_else(|| state.levels.get(&upstream).copied())
-                .unwrap_or(0);
-            level = level.max(upstream_level.saturating_add(1));
+        let schedule_levels = state.by_schedule.entry(schedule).or_default();
+        while schedule_levels.len() <= level as usize {
+            schedule_levels.push(Vec::new());
         }
+        insert_sorted_by_index(&mut schedule_levels[level as usize], signal);
+    }
+}
 
-        new_levels.insert(signal, level);
+/// Remove a signal from its current position in by_schedule.
+fn remove_signal_from_buckets(state: &mut SignalGraphState, signal: SignalSystem, old_level: u32) {
+    // Remove from by_schedule using cached schedule for O(1) lookup.
+    if let Some(&schedule) = state.signal_schedules.get(&signal)
+        && let Some(schedule_levels) = state.by_schedule.get_mut(&schedule)
+        && let Some(bucket) = schedule_levels.get_mut(old_level as usize)
+        && let Some(pos) = bucket.iter().position(|s| *s == signal)
+    {
+        bucket.remove(pos);
+    }
+}
 
-        for downstream in get_downstreams(world, signal) {
-            if !affected.contains(&downstream) {
-                continue;
-            }
-            if let Some(count) = in_degree.get_mut(&downstream) {
-                *count = count.saturating_sub(1);
-                if *count == 0 {
-                    queue.push_back(downstream);
-                }
+/// Insert a signal at its new level in by_schedule.
+fn insert_signal_into_buckets(world: &World, state: &mut SignalGraphState, signal: SignalSystem, new_level: u32) {
+    // Get schedule and insert into by_schedule
+    let schedule = world
+        .get::<SignalScheduleTag>(*signal)
+        .map(|tag| tag.0)
+        .unwrap_or(state.default_schedule);
+
+    // Update the schedule cache
+    state.signal_schedules.insert(signal, schedule);
+
+    let schedule_levels = state.by_schedule.entry(schedule).or_default();
+    while schedule_levels.len() <= new_level as usize {
+        schedule_levels.push(Vec::new());
+    }
+    insert_sorted_by_index(&mut schedule_levels[new_level as usize], signal);
+}
+
+fn update_levels_incremental(world: &mut World, state: &mut SignalGraphState, seeds: &[SignalSystem]) -> bool {
+    // Collect all signals affected by edge changes (seeds + all their downstreams).
+    let mut affected: HashSet<SignalSystem> = HashSet::new();
+    let mut queue: VecDeque<SignalSystem> = seeds.iter().copied().collect();
+
+    while let Some(signal) = queue.pop_front() {
+        if affected.insert(signal) {
+            for downstream in get_downstreams(world, signal) {
+                queue.push_back(downstream);
             }
         }
     }
+    if affected.is_empty() {
+        return true;
+    }
+
+    // Use Kahn's algorithm to compute new levels for affected signals
+    let result = compute_signal_levels(
+        world,
+        &affected,
+        |u| affected.contains(&u),         // only affected upstreams count for in-degree
+        |u| state.levels.get(&u).copied(), // unaffected upstreams use cached levels
+    );
 
-    if processed < affected.len() {
+    if !result.is_complete() {
         return false;
     }
 
-    for signal in affected {
-        if let Some(old_level) = state.levels.get(&signal).copied()
-            && let Some(bucket) = state.by_level.get_mut(old_level as usize)
-            && let Some(pos) = bucket.iter().position(|s| *s == signal)
-        {
-            bucket.remove(pos);
+    // Update state with short-circuit optimization:
+    // Only update buckets for signals whose level actually changed.
+    for &signal in &affected {
+        let old_level = state.levels.get(&signal).copied();
+        let new_level = result.levels.get(&signal).copied();
+
+        // Short-circuit: if level didn't change, skip bucket updates
+        if old_level == new_level {
+            continue;
         }
 
-        if let Some(new_level) = new_levels.get(&signal).copied() {
-            while state.by_level.len() <= new_level as usize {
-                state.by_level.push(Vec::new());
-            }
-            insert_sorted_by_index(&mut state.by_level[new_level as usize], signal);
+        // Remove from old position
+        if let Some(old) = old_level {
+            remove_signal_from_buckets(state, signal, old);
+        }
+
+        // Insert at new position
+        if let Some(new_level) = new_level {
             state.levels.insert(signal, new_level);
+            insert_signal_into_buckets(world, state, signal, new_level);
         } else {
             state.levels.remove(&signal);
+            state.signal_schedules.remove(&signal);
         }
     }
 
     true
 }
 
-fn update_edge_change_levels(world: &mut World, state: &mut SignalGraphState) {
+/// Updates signal levels based on edge changes and returns the seeds that were processed.
+///
+/// Returns the signals that were in `edge_change_seeds` before processing. This allows
+/// callers to know which signals triggered the update without needing to drain and re-add.
+fn update_edge_change_levels(world: &mut World, state: &mut SignalGraphState) -> Vec<SignalSystem> {
     if state.levels.is_empty() {
         rebuild_levels(world, state);
-        state.edge_change_seeds.clear();
-        return;
+        return state.edge_change_seeds.drain().collect();
     }
 
     if state.edge_change_seeds.is_empty() {
-        return;
+        return Vec::new();
     }
 
-    if !update_levels_incremental(world, state) {
+    // Drain seeds once and pass directly to update function
+    let seeds: Vec<SignalSystem> = state.edge_change_seeds.drain().collect();
+
+    if !update_levels_incremental(world, state, &seeds) {
         panic!("signal graph contains a cycle or inconsistent edges during incremental update");
     }
-    state.edge_change_seeds.clear();
+
+    seeds
 }
 
 fn remove_signal_from_graph_state_internal(state: &mut SignalGraphState, signal: SignalSystem) {
-    if let Some(level) = state.levels.remove(&signal)
-        && let Some(bucket) = state.by_level.get_mut(level as usize)
-        && let Some(pos) = bucket.iter().position(|s| *s == signal)
-    {
-        bucket.remove(pos);
+    if let Some(level) = state.levels.remove(&signal) {
+        remove_signal_from_buckets(state, signal, level);
     }
+    state.signal_schedules.remove(&signal);
     state.edge_change_seeds.remove(&signal);
 }
 
@@ -517,109 +801,258 @@ fn apply_deferred_removals(state: &mut SignalGraphState) {
     }
 }
 
-fn process_signal(
-    world: &mut World,
-    signal: SignalSystem,
-    inputs: &mut HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>>,
-) {
-    let runner = match world.get::<SystemRunner>(*signal).cloned() {
-        Some(runner) => runner,
-        None => {
-            if world.get_entity(*signal).is_err() {
-                // Re-entrant combinators can despawn signals during the same frame; skip these stale IDs.
-                return;
+/// Runs a signal node: reads inputs from its [`SignalInputBuffer`], executes the system,
+/// and writes outputs to downstream signals' buffers.
+///
+/// Avoids holding references to [`SignalGraphState`] during execution, since signal
+/// systems may spawn new signals that call [`pipe_signal`].
+fn run_signal_node(world: &mut World, signal: SignalSystem) {
+    // Get runner and inputs before running (to avoid borrow conflicts)
+    let (runner, signal_inputs, upstreams) = {
+        let runner = match world.get::<SystemRunner>(*signal).cloned() {
+            Some(runner) => runner,
+            None => {
+                if world.get_entity(*signal).is_err() {
+                    // Re-entrant combinators can despawn signals during the same frame; skip these stale IDs.
+                    return;
+                }
+                let upstreams = get_upstreams(world, signal);
+                let downstreams = get_downstreams(world, signal);
+                panic!(
+                    "missing SystemRunner for signal {:?} during processing (entity exists). upstreams={:?}, downstreams={:?}",
+                    signal, upstreams, downstreams
+                );
             }
-            let upstreams = get_upstreams(world, signal);
-            let downstreams = get_downstreams(world, signal);
-            panic!(
-                "missing SystemRunner for signal {:?} during processing (entity exists). upstreams={:?}, downstreams={:?}",
-                signal, upstreams, downstreams
-            );
-        }
-    };
+        };
 
-    let upstreams = get_upstreams(world, signal);
+        // Take inputs from the signal's component
+        let signal_inputs = world
+            .get_mut::<SignalInputBuffer>(*signal)
+            .map(|mut buffer| buffer.take())
+            .unwrap_or_default();
+
+        let upstreams = get_upstreams(world, signal);
 
-    if upstreams.is_empty() {
-        if let Some(output) = runner.run(world, Box::new(())) {
-            enqueue_inputs(world, inputs, signal, output);
+        (runner, signal_inputs, upstreams)
+    };
+
+    // Run the signal system
+    let final_output = if upstreams.is_empty() {
+        // Root signal - run with unit input
+        runner.run(world, Box::new(()))
+    } else if !signal_inputs.is_empty() {
+        // Run once per upstream input received, forwarding only the final output.
+        // This means a signal with multiple upstreams acts as a "collection" point:
+        // it processes each upstream's output, but only its last output propagates downstream.
+        let mut output = None;
+        for input in signal_inputs {
+            if let Some(o) = runner.run(world, input) {
+                output = Some(o);
+            }
         }
-        return;
-    }
+        output
+    } else {
+        None
+    };
 
-    let mut queue = inputs.remove(&signal).unwrap_or_default();
-    while let Some(input) = queue.pop_front() {
-        if let Some(output) = runner.run(world, input) {
-            enqueue_inputs(world, inputs, signal, output);
+    // Write outputs directly to downstream components
+    if let Some(output) = final_output {
+        let downstreams = get_downstreams(world, signal);
+        if let Some((last, rest)) = downstreams.split_last() {
+            // Clone for all but last
+            for downstream in rest {
+                if let Ok(mut entity) = world.get_entity_mut(**downstream)
+                    && let Some(mut buffer) = entity.get_mut::<SignalInputBuffer>()
+                {
+                    buffer.push(output.clone());
+                }
+            }
+            // Last downstream gets the original (no clone)
+            if let Ok(mut entity) = world.get_entity_mut(**last)
+                && let Some(mut buffer) = entity.get_mut::<SignalInputBuffer>()
+            {
+                buffer.push(output);
+            }
         }
     }
 }
 
-pub(crate) fn process_signals(world: &mut World, signals: impl AsRef<[SignalSystem]>, input: Box<dyn AnyClone>) {
+pub(crate) fn trigger_signal_subgraph(
+    world: &mut World,
+    signals: impl AsRef<[SignalSystem]>,
+    input: Box<dyn AnyClone>,
+) {
     let signals = signals.as_ref();
     if signals.is_empty() {
         return;
     }
 
-    let mut inputs: HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>> = HashMap::new();
-    let mut iter = signals.iter().copied().peekable();
-    if let Some(first) = iter.next() {
-        let mut run_with_input = |signal: SignalSystem, input: Box<dyn AnyClone>| {
-            let runner = world
-                .get::<SystemRunner>(*signal)
-                .cloned()
-                .unwrap_or_else(|| panic!("missing SystemRunner for signal {:?} during processing", signal));
-            if let Some(output) = runner.run(world, input) {
-                enqueue_inputs(world, &mut inputs, signal, output);
-            }
-        };
-
-        if iter.peek().is_none() {
-            // avoid cloning if there's only a single downstream
-            run_with_input(first, input);
-        } else {
-            let rest: Vec<SignalSystem> = iter.collect();
-            if let Some((last, rest)) = rest.split_last() {
-                for signal in core::iter::once(first).chain(rest.iter().copied()) {
-                    run_with_input(signal, input.clone());
-                }
-                run_with_input(*last, input);
+    // Pre-populate inputs for seed signals by writing to their components
+    if let Some((last, rest)) = signals.split_last() {
+        for signal in rest {
+            if let Ok(mut entity) = world.get_entity_mut(**signal)
+                && let Some(mut buffer) = entity.get_mut::<SignalInputBuffer>()
+            {
+                buffer.push(input.clone());
             }
         }
+        // Last signal gets the original (no clone)
+        if let Ok(mut entity) = world.get_entity_mut(**last)
+            && let Some(mut buffer) = entity.get_mut::<SignalInputBuffer>()
+        {
+            buffer.push(input);
+        }
     }
 
+    // Process seeds and all their downstreams in topological order.
     let by_level = downstream_levels_from_seeds(world, signals);
-    let skip: HashSet<SignalSystem> = signals.iter().copied().collect();
-    for level in by_level.into_iter().skip(1) {
+    for level in by_level {
         for signal in level {
-            if skip.contains(&signal) {
-                continue;
-            }
-            process_signal(world, signal, &mut inputs);
+            run_signal_node(world, signal);
         }
     }
 }
 
-pub(crate) fn process_signal_graph(world: &mut World) {
-    let mut levels_snapshot: Vec<Vec<SignalSystem>> = Vec::new();
-    world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
-        update_edge_change_levels(world, &mut state);
-        state.is_processing = true;
-        levels_snapshot = core::mem::take(&mut state.by_level);
-    });
+/// Creates a system that processes only signals tagged for the specified schedule.
+///
+/// Uses persistent inputs stored in [`SignalGraphState`] to enable cross-schedule data flow.
+/// Includes a fixpoint loop to process signals that are registered during processing.
+pub(crate) fn process_signal_graph_for_schedule(schedule: InternedScheduleLabel) -> impl FnMut(&mut World) {
+    move |world: &mut World| {
+        // Phase 1: Update graph if needed, take this schedule's signals (avoids cloning)
+        let levels_for_schedule: Vec<Vec<SignalSystem>> = {
+            world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+                // Recompute levels if edges changed (also updates partition incrementally)
+                let _ = update_edge_change_levels(world, &mut state);
+                state.is_processing = true;
+
+                // Take this schedule's signals to avoid cloning; we'll put them back after processing
+                state.by_schedule.remove(&schedule).unwrap_or_default()
+            })
+        };
+
+        // Track signals we've already processed this frame to avoid double-processing
+        let mut processed: HashSet<SignalSystem> = HashSet::default();
+
+        // Phase 2: Process signals level-by-level using persistent inputs
+        // Note: We don't use resource_scope here because signal processing may spawn
+        // new elements that register new signals, which calls pipe_signal, which needs
+        // to access SignalGraphState. Using resource_scope would temporarily remove
+        // the resource and cause a panic.
+        for level in &levels_for_schedule {
+            for &signal in level {
+                processed.insert(signal);
+                run_signal_node(world, signal);
+            }
+        }
+
+        // Put levels back
+        world
+            .resource_mut::<SignalGraphState>()
+            .by_schedule
+            .insert(schedule, levels_for_schedule);
+
+        // Phase 2b: Process signals registered during processing (registration recursion).
+        // This handles cases like child_signal spawning elements with their own signals.
+        let (recursion_limit, limit_behavior) = {
+            let state = world.resource::<SignalGraphState>();
+            (state.registration_recursion_limit, state.on_recursion_limit_exceeded)
+        };
+        let mut recursion_pass = 0usize;
+
+        loop {
+            recursion_pass += 1;
+
+            if recursion_pass > recursion_limit {
+                match limit_behavior {
+                    RecursionLimitBehavior::Panic => {
+                        panic!(
+                            "Signal registration recursion limit exceeded ({} passes) in schedule {:?}. \
+                             This usually indicates an infinite loop where signals keep spawning new signals. \
+                             Processed {} signals before limit was reached. \
+                             Use `JonmoPlugin::on_recursion_limit_exceeded` to change this behavior.",
+                            recursion_limit,
+                            schedule,
+                            processed.len()
+                        );
+                    }
+                    RecursionLimitBehavior::Warn => {
+                        #[cfg(feature = "tracing")]
+                        bevy_log::warn!(
+                            "Signal registration recursion limit exceeded ({} passes) in schedule {:?}. \
+                             This may indicate an infinite loop where signals keep spawning new signals. \
+                             Processed {} signals so far.",
+                            recursion_limit,
+                            schedule,
+                            processed.len()
+                        );
+                        break;
+                    }
+                    RecursionLimitBehavior::Silent => {
+                        break;
+                    }
+                }
+            }
+
+            // Update levels for new signals and get the seeds that were processed
+            let new_seeds: Vec<SignalSystem> = world
+                .resource_scope(|world, mut state: Mut<SignalGraphState>| update_edge_change_levels(world, &mut state));
+
+            if new_seeds.is_empty() {
+                break;
+            }
 
-    let mut inputs: HashMap<SignalSystem, VecDeque<Box<dyn AnyClone>>> = HashMap::new();
-    for level in &levels_snapshot {
-        for &signal in level {
-            process_signal(world, signal, &mut inputs);
+            // Get signals in this schedule that we haven't processed yet
+            let new_signals: Vec<SignalSystem> = new_seeds
+                .into_iter()
+                .filter(|s| {
+                    !processed.contains(s)
+                        && world
+                            .get::<SignalScheduleTag>(**s)
+                            .map(|tag| tag.0 == schedule)
+                            .unwrap_or(false)
+                })
+                .collect();
+
+            if new_signals.is_empty() {
+                break;
+            }
+
+            // Process new signals and their downstreams in topological order
+            let new_levels = downstream_levels_from_seeds(world, &new_signals);
+            for level in new_levels {
+                for signal in level {
+                    if processed.insert(signal) {
+                        // Only process if we haven't already
+                        if world
+                            .get::<SignalScheduleTag>(*signal)
+                            .map(|tag| tag.0 == schedule)
+                            .unwrap_or(false)
+                        {
+                            run_signal_node(world, signal);
+                        }
+                    }
+                }
+            }
         }
+
+        // Phase 3: Cleanup
+        let mut state = world.resource_mut::<SignalGraphState>();
+        state.is_processing = false;
+        apply_deferred_removals(&mut state);
     }
+}
 
-    let mut state = world.resource_mut::<SignalGraphState>();
-    state.is_processing = false;
-    state.by_level = levels_snapshot;
-    // this indirection allows us to avoid cloning the topological ordering every frame
-    apply_deferred_removals(&mut state);
+/// Clears persistent inputs at the end of each frame.
+///
+/// This should run after all signal processing systems in the frame.
+/// Clears all signal input buffers at the end of each frame.
+///
+/// This should run after all signal processing systems in the frame.
+pub(crate) fn clear_signal_inputs(mut buffers: Query<&mut SignalInputBuffer>) {
+    for mut buffer in &mut buffers {
+        buffer.clear();
+    }
 }
 
 /// Handle to a particular node of the signal graph, returned by
@@ -694,7 +1127,7 @@ impl SignalHandles {
 fn spawn_signal<I, O, IOO, F, M>(world: &mut World, system: F) -> SignalSystem
 where
     I: 'static,
-    O: Clone + 'static,
+    O: Clone + Send + Sync + 'static,
     IOO: Into<Option<O>> + 'static,
     F: IntoSystem<In<I>, IOO, M> + 'static,
 {
@@ -705,6 +1138,7 @@ where
     }));
     world.entity_mut(signal_system.entity()).insert((
         SignalRegistrationCount::new(),
+        SignalInputBuffer::default(),
         SystemRunner {
             runner: Arc::new(Box::new(move |w, inp| runner.run(w, inp))),
         },
@@ -751,7 +1185,7 @@ pub(crate) struct LazySignal {
 }
 
 impl LazySignal {
-    pub(crate) fn new<F: FnOnce(&mut World) -> SignalSystem + SSs>(system: F) -> Self {
+    pub(crate) fn new<F: FnOnce(&mut World) -> SignalSystem + Send + Sync + 'static>(system: F) -> Self {
         LazySignal {
             inner: Arc::new(LazySignalState {
                 references: AtomicUsize::new(1),
@@ -832,9 +1266,9 @@ pub(crate) fn despawn_stale_signals(world: &mut World) {
 pub(crate) fn lazy_signal_from_system<I, O, IOO, F, M>(system: F) -> LazySignal
 where
     I: 'static,
-    O: Clone + 'static,
+    O: Clone + Send + Sync + 'static,
     IOO: Into<Option<O>> + 'static,
-    F: IntoSystem<In<I>, IOO, M> + SSs,
+    F: IntoSystem<In<I>, IOO, M> + Send + Sync + 'static,
 {
     LazySignal::new(move |world: &mut World| spawn_signal(world, system))
 }
@@ -952,12 +1386,12 @@ fn unlink_from_upstream(world: &mut World, upstream_system: SignalSystem, signal
 }
 
 fn cleanup_recursive(world: &mut World, signal: SignalSystem) {
-    // Stage 1: Decrement registration and bail if the node is still in use.
+    // Decrement registration and bail if the node is still in use.
     if !decrement_registration_and_needs_cleanup(world, signal) {
         return;
     }
 
-    // Stage 2: The count is zero. Perform the full cleanup. First, get the list of parents.
+    // The count is zero. Perform the full cleanup. First, get the list of parents.
     let upstreams = world.get::<Upstream>(*signal).cloned();
 
     // Unlink downstream edges and mark affected nodes for level recomputation.
@@ -970,7 +1404,7 @@ fn cleanup_recursive(world: &mut World, signal: SignalSystem) {
         }
     }
 
-    // Stage 3: Notify parents and recurse after processing this node.
+    // Notify parents and recurse after processing this node.
     if let Some(upstreams) = upstreams {
         for &upstream_system in upstreams.iter() {
             unlink_from_upstream(world, upstream_system, signal);
@@ -979,50 +1413,144 @@ fn cleanup_recursive(world: &mut World, signal: SignalSystem) {
     }
 }
 
-fn poll_signal_one_shot(In(signal): In<SignalSystem>, world: &mut World) -> Option<Box<dyn AnyClone>> {
-    fn visit(
-        world: &mut World,
-        node: SignalSystem,
-        cache: &mut HashMap<SignalSystem, Option<Box<dyn AnyClone>>>,
-    ) -> Option<Box<dyn AnyClone>> {
-        // 1. memoisation fast-path
-        if let Some(cached) = cache.get(&node) {
-            return cached.clone();
+/// Computes topological levels for signals upstream of a target that aren't in the cached state.
+/// Uses Kahn's algorithm on the reachable subgraph.
+fn compute_levels_for_uncached(
+    world: &World,
+    reachable: &HashSet<SignalSystem>,
+    cached_levels: &HashMap<SignalSystem, u32>,
+) -> HashMap<SignalSystem, u32> {
+    let uncached: HashSet<SignalSystem> = reachable
+        .iter()
+        .filter(|s| !cached_levels.contains_key(*s))
+        .copied()
+        .collect();
+
+    // Note: upstream_filter uses `reachable` (not `uncached`) because we need to count
+    // in-degree based on the full reachable subgraph, but only compute levels for uncached signals.
+    // Cached upstreams don't contribute to in-degree since their levels are already known.
+    let result = compute_signal_levels(
+        world,
+        &uncached,
+        |u| reachable.contains(&u) && !cached_levels.contains_key(&u),
+        |u| cached_levels.get(&u).copied(),
+    );
+
+    result.levels
+}
+
+fn poll_signal_one_shot(In(target): In<SignalSystem>, world: &mut World) -> Option<Box<dyn AnyClone>> {
+    // Collect all signals reachable upstream from target
+    let mut reachable: HashSet<SignalSystem> = HashSet::new();
+    let mut queue: VecDeque<SignalSystem> = VecDeque::new();
+    queue.push_back(target);
+    reachable.insert(target);
+
+    while let Some(signal) = queue.pop_front() {
+        for upstream in get_upstreams(world, signal) {
+            if reachable.insert(upstream) {
+                queue.push_back(upstream);
+            }
         }
+    }
 
-        // 2. pull runner + upstream list
-        let runner = world
-            .get::<SystemRunner>(*node)
-            .cloned()
-            .unwrap_or_else(|| panic!("missing SystemRunner for signal {:?} during processing", node));
-        let upstreams: Vec<SignalSystem> = world
-            .get::<Upstream>(*node)
-            .map(|u| {
-                let mut v: Vec<_> = u.0.iter().copied().collect();
-                v.sort_by_key(|s| **s);
-                v
-            })
-            .unwrap_or_default();
+    // Get cached levels and compute levels for any uncached signals.
+    // We avoid cloning the entire levels HashMap by collecting only the levels we need.
 
-        // 3. run the node (depth-first)
-        let mut last_output = None;
-        if upstreams.is_empty() {
-            last_output = runner.run(world, Box::new(()));
-        } else {
-            for up in upstreams {
-                if let Some(input) = visit(world, up, cache)
-                    && let Some(out) = runner.run(world, input)
-                {
-                    last_output = Some(out);
+    // First pass: check which signals need level computation
+    let uncached: HashSet<SignalSystem> = {
+        let state = world.resource::<SignalGraphState>();
+        reachable
+            .iter()
+            .filter(|s| !state.levels.contains_key(*s))
+            .copied()
+            .collect()
+    };
+
+    // Compute levels for uncached signals if any (requires &World, so state borrow must end first)
+    let uncached_levels = if uncached.is_empty() {
+        HashMap::default()
+    } else {
+        compute_levels_for_uncached(world, &reachable, &world.resource::<SignalGraphState>().levels)
+    };
+
+    // Bucket by level using references to avoid cloning
+    let by_level = {
+        let state = world.resource::<SignalGraphState>();
+        let mut by_level: Vec<Vec<SignalSystem>> = Vec::new();
+        for signal in &reachable {
+            let level = state
+                .levels
+                .get(signal)
+                .or_else(|| uncached_levels.get(signal))
+                .copied()
+                .unwrap_or(0) as usize;
+            while by_level.len() <= level {
+                by_level.push(Vec::new());
+            }
+            by_level[level].push(*signal);
+        }
+
+        // Sort each level for determinism
+        for level in &mut by_level {
+            level.sort_by_key(|s| s.index());
+        }
+
+        by_level
+    };
+
+    // Process level by level, running each signal once per upstream input received.
+    // We only track the target's output directly instead of storing all outputs.
+    let mut inputs: HashMap<SignalSystem, Vec<Box<dyn AnyClone>>> = HashMap::new();
+    let mut target_output: Option<Box<dyn AnyClone>> = None;
+
+    for level in by_level {
+        for signal in level {
+            let runner = world
+                .get::<SystemRunner>(*signal)
+                .cloned()
+                .unwrap_or_else(|| panic!("missing SystemRunner for signal {:?} during poll", signal));
+
+            let upstreams = get_upstreams(world, signal);
+
+            let output = if upstreams.is_empty() {
+                // Source signal - run with unit input
+                runner.run(world, Box::new(()))
+            } else if let Some(input_list) = inputs.remove(&signal) {
+                // Has inputs from upstreams - run once per input, keep final output
+                let mut final_output = None;
+                for input in input_list {
+                    if let Some(out) = runner.run(world, input) {
+                        final_output = Some(out);
+                    }
+                }
+                final_output
+            } else {
+                // No input received - signal doesn't fire
+                None
+            };
+
+            // Only store output if this is the target we're polling
+            if signal == target {
+                target_output = output;
+                // Target found - no need to propagate further since we're done
+                continue;
+            }
+
+            // Propagate output to downstreams
+            if let Some(out) = output {
+                let downstreams = get_downstreams(world, signal);
+                if let Some((last, rest)) = downstreams.split_last() {
+                    for downstream in rest {
+                        inputs.entry(*downstream).or_default().push(out.clone());
+                    }
+                    inputs.entry(*last).or_default().push(out);
                 }
             }
         }
-        cache.insert(node, last_output.clone());
-        last_output
     }
 
-    let mut cache = HashMap::new();
-    visit(world, signal, &mut cache)
+    target_output
 }
 
 /// Get a signal's current value by running all of it's dependencies.
@@ -1039,12 +1567,13 @@ pub fn poll_signal(world: &mut World, signal: SignalSystem) -> Option<Box<dyn An
 /// # Example
 ///
 /// ```
-/// use bevy_ecs::prelude::*;
+/// use bevy::prelude::*;
 /// use jonmo::{prelude::*, graph::*};
 ///
-/// let mut world = World::new();
-/// let signal = *signal::from_system(|_: In<()>| 1).register(&mut world);
-/// poll_signal(&mut world, signal).and_then(downcast_any_clone::<usize>); // outputs an `Option<usize>`
+/// let mut app = App::new();
+/// app.add_plugins((MinimalPlugins, JonmoPlugin::default()));
+/// let signal = *signal::from_system(|_: In<()>| 1).register(app.world_mut());
+/// poll_signal(app.world_mut(), signal).and_then(downcast_any_clone::<usize>); // outputs an `Option<usize>`
 /// ```
 pub fn downcast_any_clone<T: 'static>(any_clone: Box<dyn AnyClone>) -> Option<T> {
     (any_clone as Box<dyn Any>).downcast::<T>().map(|o| *o).ok()
@@ -1053,11 +1582,22 @@ pub fn downcast_any_clone<T: 'static>(any_clone: Box<dyn AnyClone>) -> Option<T>
 #[cfg(test)]
 mod tests {
     use super::*;
-    use bevy_ecs::prelude::{In, Mut, World};
+
+    use bevy_ecs::{
+        prelude::{In, Mut, World},
+        schedule::ScheduleLabel,
+    };
 
     #[derive(Resource, Default)]
     struct Order(Vec<&'static str>);
 
+    /// Helper to process all signals in the default schedule for tests.
+    fn process_signals(world: &mut World) {
+        let default_schedule = world.resource::<SignalGraphState>().default_schedule;
+        let mut system = process_signal_graph_for_schedule(default_schedule);
+        system(world);
+    }
+
     #[test]
     #[should_panic(expected = "signal graph contains a cycle or inconsistent edges during incremental update")]
     fn incremental_update_panics_on_cycle() {
@@ -1105,7 +1645,7 @@ mod tests {
             Some(())
         });
 
-        process_signal_graph(&mut world);
+        process_signals(&mut world);
 
         let order = world.resource::<Order>().0.clone();
         if signal_a.0.index() < signal_b.0.index() {
@@ -1130,11 +1670,11 @@ mod tests {
             Some(())
         });
 
-        process_signal_graph(&mut world);
+        process_signals(&mut world);
         world.resource_mut::<Order>().0.clear();
 
         pipe_signal(&mut world, signal_a, signal_b);
-        process_signal_graph(&mut world);
+        process_signals(&mut world);
 
         let order = world.resource::<Order>().0.clone();
         assert_eq!(order, vec!["a", "b"]);
@@ -1198,4 +1738,357 @@ mod tests {
         assert_eq!(levels_after.get(&c), Some(&1));
         assert!(!levels_after.contains_key(&a));
     }
+
+    #[test]
+    fn schedule_tag_assigns_signal_to_schedule() {
+        use bevy_app::Update;
+
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        let signal_a = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(1));
+
+        // Tag the signal with Update schedule
+        world.entity_mut(*signal_a).insert(SignalScheduleTag(Update.intern()));
+
+        world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            rebuild_levels(world, &mut state);
+        });
+
+        let state = world.resource::<SignalGraphState>();
+        let update_signals = state.by_schedule.get(&Update.intern());
+        assert!(update_signals.is_some());
+        assert!(update_signals.unwrap().iter().flatten().any(|s| *s == signal_a));
+    }
+
+    #[test]
+    fn schedule_hint_propagates_to_downstream_via_pipe() {
+        use bevy_app::Update;
+
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        let signal_a = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(1));
+        let signal_b = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(2));
+
+        // Tag signal_a with Update schedule and set a hint for downstream
+        world
+            .entity_mut(*signal_a)
+            .insert(SignalScheduleTag(Update.intern()))
+            .insert(ScheduleHint(Update.intern()));
+
+        // Pipe a -> b (b should inherit the schedule from hint)
+        pipe_signal(&mut world, signal_a, signal_b);
+
+        // signal_b should now have the SignalScheduleTag from the hint
+        let tag = world.get::<SignalScheduleTag>(*signal_b);
+        assert!(tag.is_some());
+        assert_eq!(tag.unwrap().0, Update.intern());
+    }
+
+    #[test]
+    fn schedule_hint_does_not_override_existing_tag() {
+        use bevy_app::{Last, Update};
+
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        let signal_a = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(1));
+        let signal_b = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(2));
+
+        // Tag signal_a with Update schedule and set a hint
+        world
+            .entity_mut(*signal_a)
+            .insert(SignalScheduleTag(Update.intern()))
+            .insert(ScheduleHint(Update.intern()));
+
+        // Tag signal_b with Last schedule (explicit tag)
+        world.entity_mut(*signal_b).insert(SignalScheduleTag(Last.intern()));
+
+        // Pipe a -> b (b's explicit tag should NOT be overridden)
+        pipe_signal(&mut world, signal_a, signal_b);
+
+        // signal_b should still have Last schedule
+        let tag = world.get::<SignalScheduleTag>(*signal_b);
+        assert!(tag.is_some());
+        assert_eq!(tag.unwrap().0, Last.intern());
+    }
+
+    #[test]
+    fn by_schedule_is_partitioned_correctly() {
+        use bevy_app::Update;
+
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        let signal_update = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(1));
+        let signal_default = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(2));
+
+        // Tag one signal with Update
+        world
+            .entity_mut(*signal_update)
+            .insert(SignalScheduleTag(Update.intern()));
+
+        world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            rebuild_levels(world, &mut state);
+        });
+
+        let state = world.resource::<SignalGraphState>();
+
+        // Check Update schedule has signal_update
+        let update_signals = state.by_schedule.get(&Update.intern());
+        assert!(update_signals.is_some());
+        let update_flat: Vec<_> = update_signals.unwrap().iter().flatten().collect();
+        assert!(update_flat.contains(&&signal_update));
+        assert!(!update_flat.contains(&&signal_default));
+
+        // Check default schedule (PostUpdate) has signal_default
+        let default_signals = state.by_schedule.get(&state.default_schedule);
+        assert!(default_signals.is_some());
+        let default_flat: Vec<_> = default_signals.unwrap().iter().flatten().collect();
+        assert!(default_flat.contains(&&signal_default));
+        assert!(!default_flat.contains(&&signal_update));
+    }
+
+    #[test]
+    fn process_for_schedule_only_runs_scheduled_signals() {
+        use bevy_app::Update;
+
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+        world.insert_resource(Order::default());
+
+        let signal_update =
+            spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>, mut order: ResMut<Order>| {
+                order.0.push("update");
+                Some(())
+            });
+        let _signal_default =
+            spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>, mut order: ResMut<Order>| {
+                order.0.push("default");
+                Some(())
+            });
+
+        // Tag one signal with Update schedule
+        world
+            .entity_mut(*signal_update)
+            .insert(SignalScheduleTag(Update.intern()));
+
+        // Build levels first
+        world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            rebuild_levels(world, &mut state);
+        });
+
+        // Process only Update schedule
+        let mut process_update = process_signal_graph_for_schedule(Update.intern());
+        process_update(&mut world);
+
+        let order = world.resource::<Order>().0.clone();
+        assert_eq!(order, vec!["update"]);
+
+        // Now process default schedule
+        world.resource_mut::<Order>().0.clear();
+        let default_schedule = world.resource::<SignalGraphState>().default_schedule;
+        let mut process_default = process_signal_graph_for_schedule(default_schedule);
+        process_default(&mut world);
+
+        let order = world.resource::<Order>().0.clone();
+        assert_eq!(order, vec!["default"]);
+    }
+
+    #[test]
+    fn cross_schedule_data_flow_via_inputs() {
+        use bevy_app::Update;
+
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        #[derive(Resource, Default)]
+        struct CollectedValues(Vec<i32>);
+        world.insert_resource(CollectedValues::default());
+
+        // signal_a runs in Update, outputs 42
+        let signal_a = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(42));
+
+        // signal_b runs in PostUpdate (default), collects input
+        let signal_b = spawn_signal::<i32, (), Option<()>, _, _>(
+            &mut world,
+            |In(value): In<i32>, mut collected: ResMut<CollectedValues>| {
+                collected.0.push(value);
+                Some(())
+            },
+        );
+
+        // Tag signal_a with Update
+        world.entity_mut(*signal_a).insert(SignalScheduleTag(Update.intern()));
+
+        // Pipe a -> b (cross-schedule dependency)
+        pipe_signal(&mut world, signal_a, signal_b);
+
+        // Build levels
+        world.resource_scope(|world, mut state: Mut<SignalGraphState>| {
+            rebuild_levels(world, &mut state);
+        });
+
+        // Process Update schedule first (signal_a runs, stores output in inputs)
+        let mut process_update = process_signal_graph_for_schedule(Update.intern());
+        process_update(&mut world);
+
+        // signal_b hasn't run yet
+        assert!(world.resource::<CollectedValues>().0.is_empty());
+
+        // Process PostUpdate schedule (signal_b runs, gets input from signal_a)
+        let default_schedule = world.resource::<SignalGraphState>().default_schedule;
+        let mut process_default = process_signal_graph_for_schedule(default_schedule);
+        process_default(&mut world);
+
+        // signal_b should have received 42 from signal_a
+        assert_eq!(world.resource::<CollectedValues>().0, vec![42]);
+    }
+
+    #[test]
+    fn clear_signal_inputs_clears_inputs() {
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::default());
+
+        let signal_a = spawn_signal::<(), i32, Option<i32>, _, _>(&mut world, |_: In<()>| Some(1));
+
+        // Manually insert some inputs into the signal's buffer component
+        world
+            .get_mut::<SignalInputBuffer>(*signal_a)
+            .unwrap()
+            .push(Box::new(42i32) as Box<dyn AnyClone>);
+
+        assert!(!world.get::<SignalInputBuffer>(*signal_a).unwrap().0.is_empty());
+
+        // Clear inputs by clearing the component
+        world.get_mut::<SignalInputBuffer>(*signal_a).unwrap().clear();
+
+        assert!(world.get::<SignalInputBuffer>(*signal_a).unwrap().0.is_empty());
+    }
+
+    #[test]
+    fn signals_registered_during_processing_are_processed_same_frame() {
+        use bevy_app::Update;
+
+        // This test verifies the fixpoint loop behavior:
+        // When a signal spawns new elements that register new signals during processing,
+        // those new signals should be processed in the same frame.
+
+        #[derive(Resource, Default)]
+        struct ProcessOrder(Vec<&'static str>);
+
+        #[derive(Resource)]
+        struct ChildSignalHandle(Option<SignalSystem>);
+
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::new(Update.intern()));
+        world.insert_resource(ProcessOrder::default());
+        world.insert_resource(ChildSignalHandle(None));
+
+        // Create a "parent" signal that, when processed, registers a new "child" signal
+        let parent_signal = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>, world: &mut World| {
+            world.resource_mut::<ProcessOrder>().0.push("parent");
+
+            // Check if child already exists (to avoid infinite loop)
+            if world.resource::<ChildSignalHandle>().0.is_none() {
+                // Register a new child signal during parent's processing
+                let child_signal =
+                    spawn_signal::<(), (), Option<()>, _, _>(world, |_: In<()>, mut order: ResMut<ProcessOrder>| {
+                        order.0.push("child");
+                        Some(())
+                    });
+                // Tag child with same schedule as parent
+                world
+                    .entity_mut(*child_signal)
+                    .insert(SignalScheduleTag(Update.intern()));
+                world.resource_mut::<ChildSignalHandle>().0 = Some(child_signal);
+            }
+            Some(())
+        });
+
+        // Tag parent signal
+        world
+            .entity_mut(*parent_signal)
+            .insert(SignalScheduleTag(Update.intern()));
+
+        // Process signals - the fixpoint loop should process both parent and child
+        let mut process_system = process_signal_graph_for_schedule(Update.intern());
+        process_system(&mut world);
+
+        // Both parent and child should have been processed in the same frame
+        let order = &world.resource::<ProcessOrder>().0;
+        assert!(order.contains(&"parent"), "Parent signal should have been processed");
+        assert!(
+            order.contains(&"child"),
+            "Child signal registered during processing should also be processed"
+        );
+    }
+
+    #[test]
+    fn fixpoint_loop_handles_multiple_levels_of_spawning() {
+        use bevy_app::Update;
+
+        // Test that the fixpoint loop can handle chains: A spawns B, B spawns C
+
+        #[derive(Resource, Default)]
+        struct ProcessOrder(Vec<&'static str>);
+
+        #[derive(Resource, Default)]
+        struct SpawnedSignals(Vec<SignalSystem>);
+
+        let mut world = World::new();
+        world.insert_resource(SignalGraphState::new(Update.intern()));
+        world.insert_resource(ProcessOrder::default());
+        world.insert_resource(SpawnedSignals::default());
+
+        // Signal A: spawns signal B
+        let signal_a = spawn_signal::<(), (), Option<()>, _, _>(&mut world, |_: In<()>, world: &mut World| {
+            world.resource_mut::<ProcessOrder>().0.push("A");
+
+            let spawned = &world.resource::<SpawnedSignals>().0;
+            if spawned.is_empty() {
+                // Spawn B
+                let signal_b = spawn_signal::<(), (), Option<()>, _, _>(world, |_: In<()>, world: &mut World| {
+                    world.resource_mut::<ProcessOrder>().0.push("B");
+
+                    let spawned = &world.resource::<SpawnedSignals>().0;
+                    if spawned.len() == 1 {
+                        // B spawns C
+                        let signal_c = spawn_signal::<(), (), Option<()>, _, _>(
+                            world,
+                            |_: In<()>, mut order: ResMut<ProcessOrder>| {
+                                order.0.push("C");
+                                Some(())
+                            },
+                        );
+                        world.entity_mut(*signal_c).insert(SignalScheduleTag(Update.intern()));
+                        world.resource_mut::<SpawnedSignals>().0.push(signal_c);
+                    }
+                    Some(())
+                });
+                world.entity_mut(*signal_b).insert(SignalScheduleTag(Update.intern()));
+                world.resource_mut::<SpawnedSignals>().0.push(signal_b);
+            }
+            Some(())
+        });
+
+        world.entity_mut(*signal_a).insert(SignalScheduleTag(Update.intern()));
+
+        // Process signals
+        let mut process_system = process_signal_graph_for_schedule(Update.intern());
+        process_system(&mut world);
+
+        // All three should have been processed
+        let order = &world.resource::<ProcessOrder>().0;
+        assert!(order.contains(&"A"), "Signal A should have been processed");
+        assert!(
+            order.contains(&"B"),
+            "Signal B (spawned by A) should have been processed"
+        );
+        assert!(
+            order.contains(&"C"),
+            "Signal C (spawned by B) should have been processed"
+        );
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 4a0cc93..b76a277 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,7 +4,7 @@
     feature = "document-features",
     doc = document_features::document_features!()
 )]
-#![cfg_attr(not(test), no_std)]
+#![cfg_attr(not(any(test, feature = "std")), no_std)]
 
 extern crate alloc;
 
@@ -13,6 +13,7 @@ use bevy_ecs::{
     prelude::*,
     schedule::{InternedScheduleLabel, ScheduleLabel},
 };
+use bevy_platform::prelude::*;
 
 pub mod graph;
 pub mod signal;
@@ -43,7 +44,7 @@ cfg_if::cfg_if! {
 ///
 /// let mut app = App::new();
 /// // Or customize the schedule
-/// app.add_plugins(JonmoPlugin::new().in_schedule(PostUpdate));
+/// app.add_plugins(JonmoPlugin::new::<PostUpdate>());
 ///
 /// // Add ordering constraints using configure_sets
 /// # #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
@@ -57,25 +58,78 @@ cfg_if::cfg_if! {
 ///     SignalProcessing.before(SystemSet1).before(SystemSet2),
 /// );
 /// ```
+///
+/// # Multi-Schedule Processing
+///
+/// For advanced use cases where signals need to run in different schedules (e.g., to avoid
+/// UI flicker by spawning in `Update` rather than `PostUpdate`), register multiple schedules:
+///
+/// ```rust
+/// use bevy_app::prelude::*;
+/// use jonmo::prelude::*;
+///
+/// # let mut app = App::new();
+/// app.add_plugins(JonmoPlugin::new::<PostUpdate>().with_schedule::<Update>());
+/// ```
+///
+/// Then use `.schedule::<S>()` on individual signal chains to control which schedule they run in.
 pub struct JonmoPlugin {
-    schedule: InternedScheduleLabel,
+    schedules: Vec<InternedScheduleLabel>,
+    registration_recursion_limit: usize,
+    on_recursion_limit_exceeded: graph::RecursionLimitBehavior,
 }
 
 impl Default for JonmoPlugin {
     fn default() -> Self {
-        Self {
-            schedule: Last.intern(),
-        }
+        Self::new::<Last>()
     }
 }
 
 impl JonmoPlugin {
-    /// Create a new `JonmoPlugin` with signal processing running in the `Last` schedule.
-    pub fn new() -> Self {
-        Self::default()
+    /// Create a new `JonmoPlugin` with the given default schedule.
+    ///
+    /// The default schedule is used for signals without explicit `.schedule::<S>()` calls.
+    /// Additional schedules can be added with `.schedule::<S>()`.
+    pub fn new<S: ScheduleLabel + Default>() -> Self {
+        Self {
+            schedules: vec![S::default().intern()],
+            registration_recursion_limit: graph::DEFAULT_REGISTRATION_RECURSION_LIMIT,
+            on_recursion_limit_exceeded: graph::RecursionLimitBehavior::default(),
+        }
+    }
+
+    /// Add an additional schedule for signal processing.
+    ///
+    /// Use [`SignalExt::schedule`](crate::signal::SignalExt::schedule)
+    /// on individual signal chains to control which schedule they run in.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use bevy_app::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// # let mut app = App::new();
+    /// app.add_plugins(
+    ///     JonmoPlugin::new::<PostUpdate>() // Default schedule
+    ///         .with_schedule::<Update>(), // Additional schedule
+    /// );
+    /// ```
+    pub fn with_schedule<S: ScheduleLabel + Default>(mut self) -> Self {
+        let interned = S::default().intern();
+        if !self.schedules.contains(&interned) {
+            self.schedules.push(interned);
+        }
+        self
     }
 
-    /// Specify which schedule the signal processing systems should run in.
+    /// Set the maximum number of signal registration recursion passes per frame.
+    ///
+    /// During signal processing, signals can spawn new signals (e.g., UI elements
+    /// registering child signals). These new signals are processed in the same frame
+    /// via recursive passes. This limit prevents infinite loops.
+    ///
+    /// Default: 100
     ///
     /// # Example
     ///
@@ -83,10 +137,32 @@ impl JonmoPlugin {
     /// use bevy_app::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// JonmoPlugin::new().in_schedule(Update);
+    /// # let mut app = App::new();
+    /// app.add_plugins(JonmoPlugin::new::<Last>().registration_recursion_limit(50));
+    /// ```
+    pub fn registration_recursion_limit(mut self, limit: usize) -> Self {
+        self.registration_recursion_limit = limit;
+        self
+    }
+
+    /// Set the behavior when the signal registration recursion limit is exceeded.
+    ///
+    /// Default: [`RecursionLimitBehavior::Panic`](graph::RecursionLimitBehavior::Panic)
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use bevy_app::prelude::*;
+    /// use jonmo::{graph::RecursionLimitBehavior, prelude::*};
+    ///
+    /// # let mut app = App::new();
+    /// // In production, you might want to warn instead of panic
+    /// app.add_plugins(
+    ///     JonmoPlugin::new::<Last>().on_recursion_limit_exceeded(RecursionLimitBehavior::Warn),
+    /// );
     /// ```
-    pub fn in_schedule(mut self, schedule: impl ScheduleLabel) -> Self {
-        self.schedule = schedule.intern();
+    pub fn on_recursion_limit_exceeded(mut self, behavior: graph::RecursionLimitBehavior) -> Self {
+        self.on_recursion_limit_exceeded = behavior;
         self
     }
 }
@@ -97,24 +173,39 @@ pub struct SignalProcessing;
 
 impl Plugin for JonmoPlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<graph::SignalGraphState>();
-        app.add_systems(
-            self.schedule,
-            (
-                (
-                    signal_vec::trigger_replays::<signal_vec::VecReplayTrigger>,
-                    signal_vec::trigger_replays::<signal_map::MapReplayTrigger>,
-                ),
-                graph::process_signal_graph,
+        // First schedule is the default for signals without explicit scheduling
+        let default_schedule = self.schedules[0];
+
+        // Initialize graph state with configuration
+        app.insert_resource(graph::SignalGraphState::with_options(
+            default_schedule,
+            self.registration_recursion_limit,
+            self.on_recursion_limit_exceeded,
+        ));
+
+        // Register processing system for each schedule
+        for &schedule in &self.schedules {
+            app.add_systems(
+                schedule,
                 (
-                    graph::despawn_stale_signals,
-                    signal_vec::despawn_stale_mutable_vecs,
-                    signal_map::despawn_stale_mutable_btree_maps,
-                ),
-            )
-                .chain()
-                .in_set(SignalProcessing),
-        );
+                    (
+                        signal_vec::trigger_replays::<signal_vec::VecReplayTrigger>,
+                        signal_vec::trigger_replays::<signal_map::MapReplayTrigger>,
+                    ),
+                    graph::process_signal_graph_for_schedule(schedule),
+                    (
+                        graph::despawn_stale_signals,
+                        signal_vec::despawn_stale_mutable_vecs,
+                        signal_map::despawn_stale_mutable_btree_maps,
+                    ),
+                )
+                    .chain()
+                    .in_set(SignalProcessing),
+            );
+        }
+
+        // Clear persistent inputs at frame end (after all signal processing)
+        app.add_systems(Last, graph::clear_signal_inputs.after(SignalProcessing));
     }
 }
 
@@ -125,7 +216,7 @@ pub mod prelude {
     pub use crate::{
         JonmoPlugin,
         graph::SignalHandles,
-        signal::{self, IntoSignalEither, Signal, SignalEither, SignalExt},
+        signal::{self, BoxedSignal, IntoSignalEither, Signal, SignalEither, SignalExt},
         signal_map::{
             IntoSignalMapEither, MutableBTreeMap, MutableBTreeMapData, SignalMap, SignalMapEither, SignalMapExt,
         },
diff --git a/src/signal.rs b/src/signal.rs
index bd7c6d2..9300144 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -1,16 +1,20 @@
-//! Signal builders and combinators for constructing reactive [`System`] dependency graphs, see
-//! [`SignalExt`].
+//! Signal builders and combinators for constructing reactive [`System`] dependency graphs.
+//!
+//! This module provides the core [`Signal`] trait and its extension trait [`SignalExt`], which
+//! together form the foundation for declarative, push-based reactive dataflows in [jonmo](crate).
+//! For a high-level overview of the signal graph runtime and key concepts, see the [`Signal`] trait
+//! documentation.
 use super::{
     graph::{
-        LazySignal, SignalHandle, SignalHandles, SignalSystem, Upstream, UpstreamIter, downcast_any_clone,
-        lazy_signal_from_system, pipe_signal, poll_signal, process_signals,
+        LazySignal, SignalHandle, SignalHandles, SignalSystem, Upstream, UpstreamIter, apply_schedule_to_signal,
+        downcast_any_clone, lazy_signal_from_system, pipe_signal, poll_signal, trigger_signal_subgraph,
     },
     signal_map::{SignalMap, SignalMapExt},
     signal_vec::{ReplayOnce, SignalVec, SignalVecExt, VecDiff, trigger_replay},
-    utils::{LazyEntity, SSs, ancestor_map},
+    utils::{LazyEntity, ancestor_map},
 };
 use crate::prelude::clone;
-use bevy_ecs::{entity_disabling::Internal, prelude::*, system::SystemState};
+use bevy_ecs::{entity_disabling::Internal, prelude::*, schedule::ScheduleLabel, system::SystemState};
 cfg_if::cfg_if! {
     if #[cfg(feature = "tracing")] {
         use core::fmt;
@@ -26,9 +30,59 @@ cfg_if::cfg_if! {
 use core::{marker::PhantomData, ops};
 use dyn_clone::{DynClone, clone_trait_object};
 
-/// Monadic registration facade for structs that encapsulate some [`System`] which is a valid member
-/// of the signal graph.
-pub trait Signal: SSs {
+/// A composable node in [jonmo](crate)'s reactive dependency graph, backed by a Bevy [`System`].
+///
+/// # Overview
+///
+/// A [`Signal`] represents a node in [jonmo](crate)'s reactive dependency graph. Under the hood,
+/// each signal node is backed by a Bevy [`System`] whose output is forwarded to its downstream
+/// dependents. Signals are declarative *descriptions* of dataflow; they don't execute until
+/// registered into a [`World`] via [`SignalExt::register`], at which point the underlying systems
+/// are inserted into the ECS and wired into the graph.
+///
+/// # Runtime Model
+///
+/// Once per frame (in the schedule configured via [`JonmoPlugin`](crate::JonmoPlugin), default
+/// [`Last`](bevy_app::Last)), the signal graph is processed:
+///
+/// 1. Source signals (those with no upstreams) run first, producing outputs.
+/// 2. Outputs are forwarded to downstream signals in topological order, ensuring each signal
+///    receives its inputs only after all its upstreams have run.
+/// 3. Propagation continues recursively until all reachable signals have been processed.
+///
+/// This is a **push-based** model: values flow downstream automatically each frame a system
+/// produces output.
+///
+/// # Flow Control via [`Option`]
+///
+/// Signal systems return [`Option<T>`] (or types that convert to it). Returning [`None`] terminates
+/// propagation for that branch of the graph for the current frame, so downstream signals simply
+/// won't run. This enables filtering, gating, and conditional logic directly within the signal
+/// graph.
+///
+/// # Polling
+///
+/// While signals are push-based by default, [jonmo](crate) also provides a polling API for cases
+/// where pull-based access is needed. Polling allows you to synchronously query a signal's most
+/// recent output from within another system, providing an escape hatch from the standard push
+/// semantics.
+///
+/// # Composition
+///
+/// Signals compose via the combinators in [`SignalExt`]. Methods like [`map`](SignalExt::map),
+/// [`dedupe`](SignalExt::dedupe), [`filter`](SignalExt::filter), and [`switch`](SignalExt::switch)
+/// allow complex dataflows to be built declaratively from simple primitives. Type erasure via
+/// boxing ([`boxed`](SignalExt::boxed)) and [`SignalEither`] enable heterogeneous signal
+/// composition when concrete types differ across branches.
+///
+/// # Related Traits
+///
+/// - [`SignalExt`]: extension trait providing all signal combinators
+/// - [`SignalVec`]: collection-oriented signals with diff-based semantics for [`Vec`] mutations
+/// - [`SignalMap`]: collection-oriented signals with diff-based semantics for
+///   [`BTreeMap`](alloc::collections::BTreeMap) mutations
+/// - [`SignalDynClone`]: for signals that need to be cloneable in type-erased contexts
+pub trait Signal: Send + Sync + 'static {
     /// Output type.
     type Item;
 
@@ -72,6 +126,13 @@ impl<O: 'static> Signal for Box<dyn SignalDynClone<Item = O> + Send + Sync> {
     }
 }
 
+/// A type-erased, cloneable [`Signal`].
+///
+/// This is a convenience alias for `Box<dyn SignalDynClone<Item = T> + Send + Sync>`.
+/// Useful when you need to store signals of different concrete types in the same collection,
+/// or return them from branching logic.
+pub type BoxedSignal<T> = Box<dyn SignalDynClone<Item = T> + Send + Sync>;
+
 /// Signal graph node which takes an input of [`In<()>`] and has no upstreams. See
 /// [`from_system`] for examples.
 pub struct Source<O> {
@@ -134,6 +195,30 @@ where
     }
 }
 
+/// Signal graph node wrapper that assigns a schedule to a signal chain, see
+/// [`.schedule`](SignalExt::schedule).
+pub struct Scheduled<Sched, I> {
+    signal: LazySignal,
+    _marker: PhantomData<fn() -> (Sched, I)>,
+}
+
+impl<Sched, I> Clone for Scheduled<Sched, I> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<Sched: 'static, I: 'static> Signal for Scheduled<Sched, I> {
+    type Item = I;
+
+    fn register_boxed_signal(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.signal.register(world).into()
+    }
+}
+
 /// Signal graph node which maps its upstream [`Entity`] to a corresponding [`Component`], see
 /// [.component](SignalExt::component).
 pub struct MapComponent<Upstream, C> {
@@ -346,13 +431,15 @@ where
 }
 
 /// Signal graph node which combines two upstreams, see [`.zip`](SignalExt::zip).
+#[allow(clippy::type_complexity)]
 pub struct Zip<Left, Right>
 where
     Left: Signal,
     Right: Signal,
 {
+    left_wrapper: Map<Left, (Option<Left::Item>, Option<Right::Item>)>,
+    right_wrapper: Map<Right, (Option<Left::Item>, Option<Right::Item>)>,
     signal: LazySignal,
-    _marker: PhantomData<fn() -> (Left, Right)>,
 }
 
 impl<Left, Right> Clone for Zip<Left, Right>
@@ -362,27 +449,9 @@ where
 {
     fn clone(&self) -> Self {
         Self {
+            left_wrapper: self.left_wrapper.clone(),
+            right_wrapper: self.right_wrapper.clone(),
             signal: self.signal.clone(),
-            _marker: PhantomData,
-        }
-    }
-}
-
-/// Internal cache for [`.zip`](SignalExt::zip) combinator.
-///
-/// Each upstream updates its side. The gate signal runs once per frame and emits the latest
-/// combined output once both sides have produced at least one value.
-#[derive(Component)]
-struct ZipCache<L, R> {
-    left: Option<L>,
-    right: Option<R>,
-}
-
-impl<L, R> Default for ZipCache<L, R> {
-    fn default() -> Self {
-        Self {
-            left: None,
-            right: None,
         }
     }
 }
@@ -395,7 +464,12 @@ where
     type Item = (Left::Item, Right::Item);
 
     fn register_boxed_signal(self: Box<Self>, world: &mut World) -> SignalHandle {
-        self.signal.register(world).into()
+        let signal = self.signal.register(world);
+        let SignalHandle(left_upstream) = self.left_wrapper.register(world);
+        let SignalHandle(right_upstream) = self.right_wrapper.register(world);
+        pipe_signal(world, left_upstream, signal);
+        pipe_signal(world, right_upstream, signal);
+        SignalHandle(signal)
     }
 }
 
@@ -621,7 +695,7 @@ impl<Upstream, Switched> SignalVec for SwitchSignalVec<Upstream, Switched>
 where
     Upstream: Signal,
     Switched: SignalVec,
-    Switched::Item: Clone + SSs,
+    Switched::Item: Clone + Send + Sync + 'static,
 {
     type Item = Switched::Item;
 
@@ -658,8 +732,8 @@ impl<Upstream, Switched> SignalMap for SwitchSignalMap<Upstream, Switched>
 where
     Upstream: Signal,
     Switched: SignalMap,
-    Switched::Key: Clone + SSs,
-    Switched::Value: Clone + SSs,
+    Switched::Key: Clone + Send + Sync + 'static,
+    Switched::Value: Clone + Send + Sync + 'static,
 {
     type Key = Switched::Key;
     type Value = Switched::Value;
@@ -940,12 +1014,12 @@ cfg_if::cfg_if! {
     }
 }
 
-/// Creates a [`Source`] signal from a [`System`] that takes [`In<()>`].
-pub fn from_system<O, IOO, F, M>(system: F) -> Source<O>
+/// Creates a [`Signal`] from a [`System`] that takes [`In<()>`].
+pub fn from_system<O, IOO, F, M>(system: F) -> impl Signal<Item = O> + Clone
 where
-    O: Clone + 'static,
+    O: Clone + Send + Sync + 'static,
     IOO: Into<Option<O>> + 'static,
-    F: IntoSystem<In<()>, IOO, M> + SSs,
+    F: IntoSystem<In<()>, IOO, M> + Send + Sync + 'static,
 {
     Source {
         signal: lazy_signal_from_system(system),
@@ -953,27 +1027,27 @@ where
     }
 }
 
-/// Creates a [`Source`] signal from an [`FnMut`].
-pub fn from_function<O, F>(mut f: F) -> Source<O>
+/// Creates a [`Signal`] from an [`FnMut`].
+pub fn from_function<O, F>(mut f: F) -> impl Signal<Item = O> + Clone
 where
-    O: Clone + SSs,
-    F: FnMut() -> O + SSs,
+    O: Clone + Send + Sync + 'static,
+    F: FnMut() -> O + Send + Sync + 'static,
 {
     from_system(move |_: In<()>| f())
 }
 
-/// Creates a [`Source`] signal that always outputs a constant value.
-pub fn always<O>(value: O) -> Source<O>
+/// Creates a [`Signal`] that always outputs the same value.
+pub fn always<O>(value: O) -> impl Signal<Item = O> + Clone
 where
-    O: Clone + SSs,
+    O: Clone + Send + Sync + 'static,
 {
     from_system(move |_: In<()>| value.clone())
 }
 
 /// Creates a [`Signal`] that outputs a value once and then terminates forever.
-pub fn once<O>(value: O) -> Source<O>
+pub fn once<O>(value: O) -> impl Signal<Item = O> + Clone
 where
-    O: Clone + SSs,
+    O: Clone + Send + Sync + 'static,
 {
     from_system(move |_: In<()>, mut emitted: Local<bool>| {
         if *emitted {
@@ -985,31 +1059,34 @@ where
     })
 }
 
-/// Creates a [`Source`] signal from an [`Entity`] or [`LazyEntity`].
-pub fn from_entity(entity: impl Into<Entity> + SSs) -> Source<Entity> {
+/// Creates a [`Signal`] from an [`Entity`] or [`LazyEntity`].
+pub fn from_entity(entity: impl Into<Entity> + Send + Sync + 'static) -> impl Signal<Item = Entity> + Clone {
     let mut entity = Some(entity);
     from_system(move |_: In<()>, mut cached: Local<Option<Entity>>| {
         *cached.get_or_insert_with(|| entity.take().unwrap().into())
     })
 }
 
-/// Creates a [`Source`] signal from an [`Entity`]'s or [`LazyEntity`]'s `generations`-th generation
+/// Creates a [`Signal`] from an [`Entity`]'s or [`LazyEntity`]'s `generations`-th generation
 /// ancestor's [`Entity`], terminating for frames where it does not exist. Passing `0` to
 /// `generation` will output the [`Entity`] itself.
-pub fn from_ancestor(entity: impl Into<Entity> + SSs, generations: usize) -> Map<Source<Entity>, Entity> {
+pub fn from_ancestor(
+    entity: impl Into<Entity> + Send + Sync + 'static,
+    generations: usize,
+) -> impl Signal<Item = Entity> + Clone {
     from_entity(entity).map(ancestor_map(generations))
 }
 
-/// Creates a [`Source`] signal from an [`Entity`]'s or [`LazyEntity`]'s parent's [`Entity`],
+/// Creates a [`Signal`] from an [`Entity`]'s or [`LazyEntity`]'s parent's [`Entity`],
 /// terminating for frames where it does not exist.
-pub fn from_parent(entity: impl Into<Entity> + SSs) -> Map<Source<Entity>, Entity> {
+pub fn from_parent(entity: impl Into<Entity> + Send + Sync + 'static) -> impl Signal<Item = Entity> + Clone {
     from_ancestor(entity, 1)
 }
 
-/// Creates a [`Source`] signal from an [`Entity`] or [`LazyEntity`] and a [`Component`],
+/// Creates a [`Signal`] from an [`Entity`] or [`LazyEntity`] and a [`Component`],
 /// terminating for the frame if the [`Entity`] does not exist or the [`Component`] does not exist
 /// on the [`Entity`].
-pub fn from_component<C>(entity: impl Into<Entity> + SSs) -> Source<C>
+pub fn from_component<C>(entity: impl Into<Entity> + Send + Sync + 'static) -> impl Signal<Item = C> + Clone
 where
     C: Component + Clone,
 {
@@ -1022,9 +1099,11 @@ where
     )
 }
 
-/// Creates a [`Source`] signal from an [`Entity`] or [`LazyEntity`] and a [`Component`], always
+/// Creates a [`Signal`] from an [`Entity`] or [`LazyEntity`] and a [`Component`], always
 /// outputting an [`Option`].
-pub fn from_component_option<C>(entity: impl Into<Entity> + SSs) -> Source<Option<C>>
+pub fn from_component_option<C>(
+    entity: impl Into<Entity> + Send + Sync + 'static,
+) -> impl Signal<Item = Option<C>> + Clone
 where
     C: Component + Clone,
 {
@@ -1037,11 +1116,11 @@ where
     )
 }
 
-/// Creates a [`Source`] signal from an [`Entity`] or [`LazyEntity`] and a [`Component`], only
+/// Creates a [`Signal`] from an [`Entity`] or [`LazyEntity`] and a [`Component`], only
 /// outputting on frames where the [`Component`] has [`Changed`]. Terminates for the frame if the
 /// [`Entity`] does not exist, the [`Component`] does not exist, or the [`Component`] has not
 /// changed.
-pub fn from_component_changed<C>(entity: impl Into<Entity> + SSs) -> Source<C>
+pub fn from_component_changed<C>(entity: impl Into<Entity> + Send + Sync + 'static) -> impl Signal<Item = C> + Clone
 where
     C: Component + Clone,
 {
@@ -1056,7 +1135,7 @@ where
 
 /// Creates a signal from a [`Resource`], terminating for the frame if the [`Resource`] does not
 /// exist.
-pub fn from_resource<R>() -> Source<R>
+pub fn from_resource<R>() -> impl Signal<Item = R> + Clone
 where
     R: Resource + Clone,
 {
@@ -1064,7 +1143,7 @@ where
 }
 
 /// Creates a signal from a [`Resource`], always outputting an [`Option`].
-pub fn from_resource_option<R>() -> Source<Option<R>>
+pub fn from_resource_option<R>() -> impl Signal<Item = Option<R>> + Clone
 where
     R: Resource + Clone,
 {
@@ -1073,7 +1152,7 @@ where
 
 /// Creates a signal from a [`Resource`], only outputting on frames where the [`Resource`] has
 /// [`Changed`]. Terminates for the frame if the [`Resource`] does not exist or has not changed.
-pub fn from_resource_changed<R>() -> Source<R>
+pub fn from_resource_changed<R>() -> impl Signal<Item = R> + Clone
 where
     R: Resource + Clone,
 {
@@ -1113,7 +1192,7 @@ where
 pub fn option<S>(value: Option<S>) -> impl Signal<Item = Option<S::Item>> + Clone
 where
     S: Signal + Clone,
-    S::Item: Clone + SSs,
+    S::Item: Clone + Send + Sync + 'static,
 {
     match value {
         Some(signal) => signal.map_in(Some).left_either(),
@@ -1267,9 +1346,9 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self::Item: 'static,
-        O: Clone + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        F: IntoSystem<In<Self::Item>, IOO, M> + SSs,
+        F: IntoSystem<In<Self::Item>, IOO, M> + Send + Sync + 'static,
     {
         Map {
             upstream: self,
@@ -1296,9 +1375,9 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self::Item: 'static,
-        O: Clone + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        F: FnMut(Self::Item) -> IOO + SSs,
+        F: FnMut(Self::Item) -> IOO + Send + Sync + 'static,
     {
         self.map(move |In(item)| function(item))
     }
@@ -1322,9 +1401,9 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self::Item: 'static,
-        O: Clone + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        F: FnMut(&Self::Item) -> IOO + SSs,
+        F: FnMut(&Self::Item) -> IOO + Send + Sync + 'static,
     {
         self.map(move |In(item)| function(&item))
     }
@@ -1471,7 +1550,7 @@ pub trait SignalExt: Signal {
     fn dedupe(self) -> Dedupe<Self>
     where
         Self: Sized,
-        Self::Item: PartialEq + Clone + Send + 'static,
+        Self::Item: PartialEq + Clone + Send + Sync + 'static,
     {
         Dedupe {
             signal: self.map(|In(current): In<Self::Item>, mut cache: Local<Option<Self::Item>>| {
@@ -1515,7 +1594,7 @@ pub trait SignalExt: Signal {
     fn take(self, count: usize) -> Take<Self>
     where
         Self: Sized,
-        Self::Item: Clone + 'static,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         Take {
             signal: self.map(move |In(item): In<Self::Item>, mut emitted: Local<usize>| {
@@ -1548,7 +1627,7 @@ pub trait SignalExt: Signal {
     fn first(self) -> First<Self>
     where
         Self: Sized,
-        Self::Item: Clone + 'static,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         First { signal: self.take(1) }
     }
@@ -1611,7 +1690,7 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         <Self as Signal>::Item: ops::Not + 'static,
-        <<Self as Signal>::Item as ops::Not>::Output: Clone,
+        <<Self as Signal>::Item as ops::Not>::Output: Clone + Send + Sync,
     {
         Not {
             signal: self.map(|In(item): In<Self::Item>| ops::Not::not(item)),
@@ -1634,10 +1713,10 @@ pub trait SignalExt: Signal {
     /// })
     /// .filter(|In(i): In<usize>| i % 2 == 0); // outputs `2`, `4`, `6`, `8`, ...
     /// ```
-    fn filter<M>(self, predicate: impl IntoSystem<In<Self::Item>, bool, M> + SSs) -> Filter<Self>
+    fn filter<M>(self, predicate: impl IntoSystem<In<Self::Item>, bool, M> + Send + Sync + 'static) -> Filter<Self>
     where
         Self: Sized,
-        Self::Item: Clone + 'static,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let system = world.register_system(predicate);
@@ -1679,48 +1758,34 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Other: Signal,
-        Self::Item: Clone + SSs,
-        Other::Item: Clone + SSs,
+        Self::Item: Clone + Send + Sync + 'static,
+        Other::Item: Clone + Send + Sync + 'static,
     {
-        let signal = LazySignal::new(move |world: &mut World| {
-            let zip_entity = LazyEntity::new();
-
-            let left_wrapper = self.map(clone!((zip_entity) move |In(left): In<Self::Item>, world: &mut World| {
-                world.get_mut::<ZipCache<Self::Item, Other::Item>>(*zip_entity).unwrap().left = Some(left);
-            }));
-            let right_wrapper = other.map(
-                clone!((zip_entity) move |In(right): In<Other::Item>, world: &mut World| {
-                    world.get_mut::<ZipCache<Self::Item, Other::Item>>(*zip_entity).unwrap().right = Some(right);
-                }),
-            );
-
-            let zip_signal = lazy_signal_from_system::<_, (Self::Item, Other::Item), _, _, _>(
-                clone!((zip_entity) move |_: In<()>, world: &mut World| {
-                    let cache = world.get_mut::<ZipCache<Self::Item, Other::Item>>(*zip_entity).unwrap();
-                    match (&cache.left, &cache.right) {
-                        (Some(left), Some(right)) => Some((left.clone(), right.clone())),
-                        _ => None,
-                    }
-                }),
-            );
-
-            let signal = zip_signal.register(world);
-            world
-                .entity_mut(*signal)
-                .insert(ZipCache::<Self::Item, Other::Item>::default());
-            zip_entity.set(*signal);
-
-            let SignalHandle(left_upstream) = left_wrapper.register(world);
-            let SignalHandle(right_upstream) = right_wrapper.register(world);
-            pipe_signal(world, left_upstream, signal);
-            pipe_signal(world, right_upstream, signal);
-
-            signal
-        });
+        let left_wrapper = self.map(|In(left): In<Self::Item>| (Some(left), None::<Other::Item>));
+        let right_wrapper = other.map(|In(right): In<Other::Item>| (None::<Self::Item>, Some(right)));
+        let signal = lazy_signal_from_system::<_, (Self::Item, Other::Item), _, _, _>(
+            #[allow(clippy::type_complexity)]
+            move |In((left_option, right_option)): In<(Option<Self::Item>, Option<Other::Item>)>,
+                  mut left_cache: Local<Option<Self::Item>>,
+                  mut right_cache: Local<Option<Other::Item>>| {
+                if left_option.is_some() {
+                    *left_cache = left_option;
+                }
+                if right_option.is_some() {
+                    *right_cache = right_option;
+                }
+                if left_cache.is_some() && right_cache.is_some() {
+                    left_cache.clone().zip(right_cache.clone())
+                } else {
+                    None
+                }
+            },
+        );
 
         Zip {
+            left_wrapper,
+            right_wrapper,
             signal,
-            _marker: PhantomData,
         }
     }
 
@@ -1741,9 +1806,9 @@ pub trait SignalExt: Signal {
     ///     .dedupe()
     ///     .map(move |In(toggle): In<Toggle>| {
     ///         if toggle.0 {
-    ///             signal::from_system(|_: In<()>| 1)
+    ///             signal::from_system(|_: In<()>| 1).left_either()
     ///         } else {
-    ///             signal::from_system(|_: In<()>| 2)
+    ///             signal::from_system(|_: In<()>| 2).right_either()
     ///         }
     ///     })
     ///     .flatten();
@@ -1764,12 +1829,12 @@ pub trait SignalExt: Signal {
         }
 
         let signal = LazySignal::new(move |world: &mut World| {
-            // 1. State entity that holds the latest value, serving as the communication channel between dynamic
-            //    inner signals and the static output signal.
+            // State entity that holds the latest value, serving as the communication channel between dynamic
+            // inner signals and the static output signal.
             let reader_entity = LazyEntity::new();
 
-            // 2. The output signal (reader). Reads from state and propagates. Has no upstream dependencies;
-            //    triggered manually by the forwarder.
+            // The output signal (reader). Reads from state and propagates. Has no upstream dependencies;
+            // triggered manually by the forwarder.
             let reader_system = *from_system::<<Self::Item as Signal>::Item, _, _, _>(
                     clone!((reader_entity) move |_: In<()>, mut query: Query<&mut FlattenState<<Self::Item as Signal>::Item>, Allow<Internal>>| {
                         query.get_mut(*reader_entity).unwrap().value.take()
@@ -1781,32 +1846,29 @@ pub trait SignalExt: Signal {
                 .entity_mut(*reader_system)
                 .insert(FlattenState::<<Self::Item as Signal>::Item> { value: None });
 
-            // 3. The subscription manager. Reacts to the outer signal emitting new inner signals.
+            // The subscription manager reacts to the outer signal emitting new inner signals.
             let manager_system = self
                 .map(
                     move |In(inner_signal): In<Self::Item>,
                           world: &mut World,
                           mut active_forwarder: Local<Option<SignalHandle>>,
                           mut active_signal_id: Local<Option<SignalSystem>>| {
-                        // a. Get the canonical ID. `register` is idempotent for existing signals.
+                        // `register` is idempotent for existing signals.
                         let new_signal_id = inner_signal.clone().register(world);
 
-                        // b. Memoization: if unchanged, balance the ref-count and return early.
+                        // If unchanged, balance the ref-count and return early.
                         if Some(*new_signal_id) == *active_signal_id {
                             new_signal_id.cleanup(world);
                             return;
                         }
 
-                        // c. Clean up the old forwarder.
                         if let Some(old_handle) = active_forwarder.take() {
                             old_handle.cleanup(world);
                         }
 
-                        // d. Poll the initial value synchronously.
                         let initial_value = poll_signal(world, *new_signal_id)
                             .and_then(downcast_any_clone::<<Self::Item as Signal>::Item>);
 
-                        // e. Write initial value to state.
                         if let Some(value) = initial_value {
                             world
                                 .get_mut::<FlattenState<<Self::Item as Signal>::Item>>(*reader_system)
@@ -1814,28 +1876,26 @@ pub trait SignalExt: Signal {
                                 .value = Some(value);
                         }
 
-                        // f. Set up forwarder for subsequent values.
+                        // Forward subsequent values to the reader.
                         let forwarder_handle = inner_signal
                             .map(move |In(value), world: &mut World| {
                                 world
                                     .get_mut::<FlattenState<<Self::Item as Signal>::Item>>(*reader_system)
                                     .unwrap()
                                     .value = Some(value);
-                                process_signals(world, [reader_system], Box::new(()));
+                                trigger_signal_subgraph(world, [reader_system], Box::new(()));
                             })
                             .register(world);
 
-                        // g. Store handles for next frame's memoization check.
                         *active_forwarder = Some(forwarder_handle);
                         *active_signal_id = Some(*new_signal_id);
 
-                        // h. Trigger reader to consume the initial value.
-                        process_signals(world, [reader_system], Box::new(()));
+                        trigger_signal_subgraph(world, [reader_system], Box::new(()));
                     },
                 )
                 .register(world);
 
-            // 4. Entity hierarchy for automatic cleanup.
+            // Entity hierarchy for automatic cleanup.
             world
                 .entity_mut(*reader_system)
                 .insert(SignalHandles::from([manager_system]));
@@ -1865,9 +1925,9 @@ pub trait SignalExt: Signal {
     ///         .dedupe()
     ///         .switch(move |In(toggle): In<Toggle>| {
     ///             if toggle.0 {
-    ///                 signal::from_system(|_: In<()>| 1)
+    ///                 signal::from_system(|_: In<()>| 1).left_either()
     ///             } else {
-    ///                 signal::from_system(|_: In<()>| 2)
+    ///                 signal::from_system(|_: In<()>| 2).right_either()
     ///             }
     ///         });
     /// // `signal` outputs `2`
@@ -1880,7 +1940,7 @@ pub trait SignalExt: Signal {
         Self::Item: 'static,
         S: Signal + Clone + 'static,
         S::Item: Clone + Send + Sync,
-        F: IntoSystem<In<Self::Item>, S, M> + SSs,
+        F: IntoSystem<In<Self::Item>, S, M> + Send + Sync + 'static,
     {
         Switch {
             signal: self.map(switcher).flatten(),
@@ -1890,6 +1950,14 @@ pub trait SignalExt: Signal {
     /// Maps this [`Signal`]'s output to a [`SignalVec`], switching to its output. Useful when the
     /// reactive list target changes depending on some other state.
     ///
+    /// **Note:** The switched [`SignalVec`] must be downstream of a
+    /// [`MutableVec`](super::signal_vec::MutableVec) to ensure proper replay of initial state
+    /// on switch. The following do not yet work with this combinator:
+    /// [`SignalExt::to_signal_vec`],
+    /// [`MutableBTreeMap::signal_vec_keys`](super::signal_map::MutableBTreeMap::signal_vec_keys),
+    /// and
+    /// [`MutableBTreeMap::signal_vec_entries`](super::signal_map::MutableBTreeMap::signal_vec_entries).
+    ///
     /// # Example
     ///
     /// ```
@@ -1925,15 +1993,17 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         S: SignalVec + Clone,
-        S::Item: Clone + SSs,
-        F: IntoSystem<In<Self::Item>, S, M> + SSs,
+        S::Item: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<Self::Item>, S, M> + Send + Sync + 'static,
     {
-        let signal = LazySignal::new(move |world: &mut World| {
-            // A private component to queue diffs for the output system.
-            #[derive(Component)]
-            struct SwitcherQueue<T: SSs>(Vec<VecDiff<T>>);
+        // Private component to queue diffs, serving as the communication channel between dynamic
+        // inner signal vecs and the static output signal.
+        #[derive(Component)]
+        struct SwitcherQueue<T: Send + Sync + 'static>(Vec<VecDiff<T>>);
 
-            // The output system is a "poller". It runs when poked and drains its own queue.
+        let signal = LazySignal::new(move |world: &mut World| {
+            // The output signal (reader). Reads from queue and propagates. Has no upstream
+            // dependencies; triggered manually by the forwarder.
             let output_signal_entity = LazyEntity::new();
             let output_signal = *from_system::<Vec<VecDiff<S::Item>>, _, _, _>(
                 clone!((output_signal_entity) move |_: In<()>, mut q: Query<&mut SwitcherQueue<S::Item>, Allow<Internal>>| {
@@ -1947,56 +2017,46 @@ pub trait SignalExt: Signal {
             )
             .register(world);
             output_signal_entity.set(*output_signal);
-
-            // Add the queue component to the output signal's entity so it can be found.
             world
                 .entity_mut(*output_signal)
                 .insert(SwitcherQueue(Vec::<VecDiff<S::Item>>::new()));
 
-            // This is the core logic. It runs whenever the outer signal changes.
+            // The subscription manager reacts to the outer signal emitting new inner signal vecs.
             let manager_system =
                 move |In(inner_signal_vec): In<S>,
                       world: &mut World,
                       mut active_forwarder: Local<Option<SignalHandle>>,
                       mut active_signal: Local<Option<SignalSystem>>| {
-                    // A. Get the canonical ID by registering. We need this for memoization.
+                    // `register` is idempotent for existing signals.
                     let new_signal_handle = inner_signal_vec.clone().register_signal_vec(world);
                     let new_signal = *new_signal_handle;
 
-                    // B. MEMOIZATION: If the signal hasn't changed, do nothing.
+                    // If unchanged, balance the ref-count and return early.
                     if Some(new_signal) == *active_signal {
-                        // Balance the ref count for this temporary handle.
                         new_signal_handle.cleanup(world);
                         return;
                     }
 
-                    // C. TEARDOWN: The signal is new. Clean up the old forwarder and the old
-                    // memoization handle.
                     if let Some(old_handle) = active_forwarder.take() {
                         old_handle.cleanup(world);
                     }
+
                     *active_signal = Some(new_signal);
 
-                    // D. FORWARDING: The forwarder's only job is to queue ALL diffs from the inner
-                    // signal and poke the output signal.
+                    // Forward diffs to the output signal's queue.
                     let forwarder_logic = move |In(diffs): In<Vec<VecDiff<S::Item>>>, world: &mut World| {
                         if !diffs.is_empty() {
                             // The output signal may have been cleaned up during a cleanup race.
                             if let Some(mut queue) = world.get_mut::<SwitcherQueue<S::Item>>(*output_signal) {
                                 queue.0.extend(diffs);
-                                process_signals(world, [output_signal], Box::new(()));
+                                trigger_signal_subgraph(world, [output_signal], Box::new(()));
                             }
                         }
                     };
-
-                    // E. PERSIST: Register the new forwarder to listen for diffs, and store both the
-                    // forwarder's handle and the new memoization handle.
                     let new_forwarder_handle = inner_signal_vec.for_each(forwarder_logic).register(world);
                     *active_forwarder = Some(new_forwarder_handle);
 
-                    // F. MANUALLY TRIGGER REPLAY: Take the trigger from the new signal and run it
-                    // _now_. This synchronously sends the initial `Replace` diff through the pipe we
-                    // just established.
+                    // Synchronously send the initial `Replace` diff.
                     let mut upstreams = SystemState::<Query<&Upstream, Allow<Internal>>>::new(world);
                     let upstreams = upstreams.get(world);
                     let upstreams = UpstreamIter::new(&upstreams, new_signal).collect::<Vec<_>>();
@@ -2010,7 +2070,7 @@ pub trait SignalExt: Signal {
                     }
                 };
 
-            // Register the manager and tie its lifecycle to the output signal.
+            // Entity hierarchy for automatic cleanup.
             let manager_handle = self.map(switcher).map(manager_system).register(world);
             world
                 .entity_mut(*output_signal)
@@ -2061,16 +2121,18 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         S: SignalMap + Clone,
-        S::Key: Clone + SSs,
-        S::Value: Clone + SSs,
-        F: IntoSystem<In<Self::Item>, S, M> + SSs,
+        S::Key: Clone + Send + Sync + 'static,
+        S::Value: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<Self::Item>, S, M> + Send + Sync + 'static,
     {
-        let signal = LazySignal::new(move |world: &mut World| {
-            // A private component to queue diffs for the output signal.
-            #[derive(Component)]
-            struct SwitcherQueue<K: SSs, V: SSs>(Vec<super::signal_map::MapDiff<K, V>>);
+        // Private component to queue diffs, serving as the communication channel between dynamic
+        // inner signal maps and the static output signal.
+        #[derive(Component)]
+        struct SwitcherQueue<K: Send + Sync + 'static, V: Send + Sync + 'static>(Vec<super::signal_map::MapDiff<K, V>>);
 
-            // The output signal is a "poller". It runs when poked and drains its own queue.
+        let signal = LazySignal::new(move |world: &mut World| {
+            // The output signal (reader). Reads from queue and propagates. Has no upstream
+            // dependencies; triggered manually by the forwarder.
             let output_signal_entity = LazyEntity::new();
             let output_signal = *from_system::<Vec<super::signal_map::MapDiff<S::Key, S::Value>>, _, _, _>(
                 clone!((output_signal_entity) move |_: In<()>, mut q: Query<&mut SwitcherQueue<S::Key, S::Value>, Allow<Internal>>| {
@@ -2084,57 +2146,47 @@ pub trait SignalExt: Signal {
             )
             .register(world);
             output_signal_entity.set(*output_signal);
-
-            // Add the queue component to the output signal's entity so it can be found.
             world
                 .entity_mut(*output_signal)
                 .insert(SwitcherQueue(Vec::<super::signal_map::MapDiff<S::Key, S::Value>>::new()));
 
-            // This is the core logic. It runs whenever the outer signal changes.
+            // The subscription manager reacts to the outer signal emitting new inner signal maps.
             let manager_system =
                 move |In(inner_signal_map): In<S>,
                       world: &mut World,
                       mut active_forwarder: Local<Option<SignalHandle>>,
                       mut active_signal: Local<Option<SignalSystem>>| {
-                    // A. Get the canonical ID by registering. We need this for memoization.
+                    // `register` is idempotent for existing signals.
                     let new_signal_handle = inner_signal_map.clone().register_signal_map(world);
                     let new_signal = *new_signal_handle;
 
-                    // B. MEMOIZATION: If the signal hasn't changed, do nothing.
+                    // If unchanged, balance the ref-count and return early.
                     if Some(new_signal) == *active_signal {
-                        // Balance the ref count for this temporary handle.
                         new_signal_handle.cleanup(world);
                         return;
                     }
 
-                    // C. TEARDOWN: The signal is new. Clean up the old forwarder and the old
-                    // memoization handle.
                     if let Some(old_handle) = active_forwarder.take() {
                         old_handle.cleanup(world);
                     }
+
                     *active_signal = Some(new_signal);
 
-                    // D. FORWARDING: The forwarder's only job is to queue ALL diffs from the inner
-                    // signal and poke the output signal.
+                    // Forward diffs to the output signal's queue.
                     let forwarder_logic = move |In(diffs): In<Vec<super::signal_map::MapDiff<S::Key, S::Value>>>,
                                                 world: &mut World| {
                         if !diffs.is_empty() {
                             // The output signal may have been cleaned up during a cleanup race.
                             if let Some(mut queue) = world.get_mut::<SwitcherQueue<S::Key, S::Value>>(*output_signal) {
                                 queue.0.extend(diffs);
-                                process_signals(world, [output_signal], Box::new(()));
+                                trigger_signal_subgraph(world, [output_signal], Box::new(()));
                             }
                         }
                     };
-
-                    // E. PERSIST: Register the new forwarder to listen for diffs, and store both the
-                    // forwarder's handle and the new memoization handle.
                     let new_forwarder_handle = inner_signal_map.for_each(forwarder_logic).register(world);
                     *active_forwarder = Some(new_forwarder_handle);
 
-                    // F. MANUALLY TRIGGER REPLAY: Take the trigger from the new signal and run it
-                    // _now_. This synchronously sends the initial `Replace` diff through the pipe we
-                    // just established.
+                    // Synchronously send the initial `Replace` diff.
                     let mut upstreams = SystemState::<Query<&Upstream, Allow<Internal>>>::new(world);
                     let upstreams = upstreams.get(world);
                     let upstreams = UpstreamIter::new(&upstreams, new_signal).collect::<Vec<_>>();
@@ -2148,7 +2200,7 @@ pub trait SignalExt: Signal {
                     }
                 };
 
-            // Register the manager and tie its lifecycle to the output signal.
+            // Entity hierarchy for automatic cleanup.
             let manager_handle = self.map(switcher).map(manager_system).register(world);
             world
                 .entity_mut(*output_signal)
@@ -2182,7 +2234,7 @@ pub trait SignalExt: Signal {
     fn throttle(self, duration: Duration) -> Throttle<Self>
     where
         Self: Sized,
-        Self::Item: Clone + 'static,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         Throttle {
             signal: self.map(
@@ -2226,10 +2278,10 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self: Signal<Item = bool>,
-        O: Clone + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        TF: IntoSystem<In<()>, IOO, TM> + SSs,
-        FF: IntoSystem<In<()>, IOO, FM> + SSs,
+        TF: IntoSystem<In<()>, IOO, TM> + Send + Sync + 'static,
+        FF: IntoSystem<In<()>, IOO, FM> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let true_system = world.register_system(true_system);
@@ -2276,10 +2328,10 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self: Signal<Item = bool>,
-        O: Clone + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        TF: FnMut() -> IOO + SSs,
-        FF: FnMut() -> IOO + SSs,
+        TF: FnMut() -> IOO + Send + Sync + 'static,
+        FF: FnMut() -> IOO + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let SignalHandle(signal) = self
@@ -2318,8 +2370,8 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self: Signal<Item = bool>,
-        O: Clone + 'static,
-        F: IntoSystem<In<()>, O, M> + SSs,
+        O: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<()>, O, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let true_system = world.register_system(system);
@@ -2364,8 +2416,8 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self: Signal<Item = bool>,
-        O: Clone + 'static,
-        F: FnMut() -> O + SSs,
+        O: Clone + Send + Sync + 'static,
+        F: FnMut() -> O + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let SignalHandle(signal) = self
@@ -2404,8 +2456,8 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self: Signal<Item = bool>,
-        O: Clone + 'static,
-        F: IntoSystem<In<()>, O, M> + SSs,
+        O: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<()>, O, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let false_system = world.register_system(system);
@@ -2450,8 +2502,8 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self: Signal<Item = bool>,
-        O: Clone + 'static,
-        F: FnMut() -> O + SSs,
+        O: Clone + Send + Sync + 'static,
+        F: FnMut() -> O + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let SignalHandle(signal) = self
@@ -2493,10 +2545,10 @@ pub trait SignalExt: Signal {
         Self: Sized,
         Self: Signal<Item = Option<I>>,
         I: 'static,
-        O: Clone + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        SF: IntoSystem<In<I>, IOO, SM> + SSs,
-        NF: IntoSystem<In<()>, IOO, NM> + SSs,
+        SF: IntoSystem<In<I>, IOO, SM> + Send + Sync + 'static,
+        NF: IntoSystem<In<()>, IOO, NM> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let some_system = world.register_system(some_system);
@@ -2542,10 +2594,10 @@ pub trait SignalExt: Signal {
         Self: Sized,
         Self: Signal<Item = Option<I>>,
         I: 'static,
-        O: Clone + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        SF: FnMut(I) -> IOO + SSs,
-        NF: FnMut() -> IOO + SSs,
+        SF: FnMut(I) -> IOO + Send + Sync + 'static,
+        NF: FnMut() -> IOO + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let SignalHandle(signal) = self
@@ -2586,8 +2638,8 @@ pub trait SignalExt: Signal {
         Self: Sized,
         Self: Signal<Item = Option<I>>,
         I: 'static,
-        O: Clone + 'static,
-        F: IntoSystem<In<I>, O, M> + SSs,
+        O: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<I>, O, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let some_system = world.register_system(system);
@@ -2630,8 +2682,8 @@ pub trait SignalExt: Signal {
         Self: Sized,
         Self: Signal<Item = Option<I>>,
         I: 'static,
-        O: Clone + 'static,
-        F: FnMut(I) -> O + SSs,
+        O: Clone + Send + Sync + 'static,
+        F: FnMut(I) -> O + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let SignalHandle(signal) = self
@@ -2670,8 +2722,8 @@ pub trait SignalExt: Signal {
         Self: Sized,
         Self: Signal<Item = Option<I>>,
         I: 'static,
-        O: Clone + 'static,
-        F: IntoSystem<In<()>, O, M> + SSs,
+        O: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<()>, O, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let none_system = world.register_system(none_system);
@@ -2714,8 +2766,8 @@ pub trait SignalExt: Signal {
         Self: Sized,
         Self: Signal<Item = Option<I>>,
         I: 'static,
-        O: Clone + 'static,
-        F: FnMut() -> O + SSs,
+        O: Clone + Send + Sync + 'static,
+        F: FnMut() -> O + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let SignalHandle(signal) = self
@@ -2763,7 +2815,7 @@ pub trait SignalExt: Signal {
     where
         Self: Sized,
         Self: Signal<Item = Vec<T>>,
-        T: PartialEq + Clone + Send + 'static,
+        T: PartialEq + Clone + Send + Sync + 'static,
     {
         let lazy_signal = LazySignal::new(move |world: &mut World| {
             let handle = self
@@ -2796,7 +2848,7 @@ pub trait SignalExt: Signal {
     fn debug(self) -> Debug<Self>
     where
         Self: Sized,
-        Self::Item: fmt::Debug + Clone + 'static,
+        Self::Item: fmt::Debug + Clone + Send + Sync + 'static,
     {
         let location = core::panic::Location::caller();
         Debug {
@@ -2850,13 +2902,70 @@ pub trait SignalExt: Signal {
     ///     signal::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 SignalDynClone<Item = Self::Item>>
+    fn boxed_clone(self) -> Box<dyn SignalDynClone<Item = Self::Item> + Send + Sync>
     where
         Self: Sized + Clone,
     {
         Box::new(self)
     }
 
+    /// Assign a schedule to this signal chain.
+    ///
+    /// When registered, signals in the chain will be tagged to run in the specified schedule,
+    /// enabling control over when signal processing occurs within each frame.
+    ///
+    /// # Semantics
+    ///
+    /// `.schedule::<S>()` applies the schedule `S` to:
+    /// 1. The signal it's called on (the "caller")
+    /// 2. All upstream signals that don't already have a schedule
+    /// 3. All downstream signals (via hint inheritance), until another `.schedule()` is encountered
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_app::prelude::*;
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// // All signals in this chain run in the Update schedule
+    /// let signal = signal::from_system(|_: In<()>| Some(42i32))
+    ///     .map_in(|x: i32| x + 1)
+    ///     .schedule::<Update>();
+    /// ```
+    ///
+    /// # Multi-Schedule Chains
+    ///
+    /// Multiple `.schedule()` calls create schedule boundaries. Each `.schedule()` tags
+    /// the signal it's called on (the "caller"):
+    ///
+    /// ```
+    /// use bevy_app::prelude::*;
+    /// use bevy_ecs::prelude::*;
+    /// use jonmo::prelude::*;
+    ///
+    /// let signal = signal::from_system(|_: In<()>| Some(1i32)) // Update (upstream propagation)
+    ///     .map_in(|x: i32| x + 1) // Update (caller of .schedule::<Update>())
+    ///     .schedule::<Update>()
+    ///     .map_in(|x: i32| x * 2) // PostUpdate (caller of .schedule::<PostUpdate>())
+    ///     .schedule::<PostUpdate>()
+    ///     .map_in(|x: i32| x - 1); // PostUpdate (inherits from above)
+    /// ```
+    fn schedule<Sched: ScheduleLabel + Default + 'static>(self) -> Scheduled<Sched, Self::Item>
+    where
+        Self: Sized + 'static,
+    {
+        let signal = LazySignal::new(move |world: &mut World| {
+            let handle = self.register_signal(world);
+            apply_schedule_to_signal(world, *handle, Sched::default().intern());
+            *handle
+        });
+        Scheduled {
+            signal,
+            _marker: PhantomData,
+        }
+    }
+
     /// Activate this [`Signal`] and all its upstreams, causing them to be evaluated
     /// every frame until they are [`SignalHandle::cleanup`]-ed, see [`SignalHandle`].
     fn register(self, world: &mut World) -> SignalHandle
@@ -3266,9 +3375,9 @@ mod tests {
         JonmoPlugin,
         graph::{LazySignalHolder, SignalRegistrationCount},
         prelude::{IntoSignalVecEither, SignalVecExt, clone},
-        signal::{self, SignalExt, Upstream},
+        signal::{self, BoxedSignal, SignalExt, Upstream},
         signal_vec::{MutableVec, VecDiff},
-        utils::{LazyEntity, SSs},
+        utils::LazyEntity,
     };
     use core::{convert::identity, fmt};
 
@@ -3286,10 +3395,10 @@ mod tests {
     struct TestData(i32);
 
     #[derive(Resource, Default, Debug)]
-    struct SignalOutput<T: SSs + Clone + fmt::Debug>(Option<T>);
+    struct SignalOutput<T: Send + Sync + 'static + Clone + fmt::Debug>(Option<T>);
 
     #[derive(Resource, Default, Debug)]
-    struct SignalOutputVec<T: SSs + Clone + fmt::Debug>(Vec<T>);
+    struct SignalOutputVec<T: Send + Sync + 'static + Clone + fmt::Debug>(Vec<T>);
 
     fn create_test_app() -> App {
         let mut app = App::new();
@@ -3299,7 +3408,10 @@ mod tests {
     }
 
     // Helper system to capture signal output
-    fn capture_output<T: SSs + Clone + fmt::Debug>(In(value): In<T>, mut output: ResMut<SignalOutput<T>>) {
+    fn capture_output<T: Send + Sync + 'static + Clone + fmt::Debug>(
+        In(value): In<T>,
+        mut output: ResMut<SignalOutput<T>>,
+    ) {
         #[cfg(feature = "tracing")]
         bevy_log::debug!(
             "Capture Output System: Received {:?}, updating resource from {:?} to Some({:?})",
@@ -3310,15 +3422,18 @@ mod tests {
         output.0 = Some(value);
     }
 
-    fn get_output<T: SSs + Clone + fmt::Debug>(world: &World) -> Option<T> {
+    fn get_output<T: Send + Sync + 'static + Clone + fmt::Debug>(world: &World) -> Option<T> {
         world.resource::<SignalOutput<T>>().0.clone()
     }
 
-    fn capture_output_vec<T: SSs + Clone + fmt::Debug>(In(value): In<T>, mut output: ResMut<SignalOutputVec<T>>) {
+    fn capture_output_vec<T: Send + Sync + 'static + Clone + fmt::Debug>(
+        In(value): In<T>,
+        mut output: ResMut<SignalOutputVec<T>>,
+    ) {
         output.0.push(value);
     }
 
-    fn get_and_clear_output_vec<T: SSs + Clone + fmt::Debug>(world: &mut World) -> Vec<T> {
+    fn get_and_clear_output_vec<T: Send + Sync + 'static + Clone + fmt::Debug>(world: &mut World) -> Vec<T> {
         world
             .get_resource_mut::<SignalOutputVec<T>>()
             .map(|mut res| core::mem::take(&mut res.0))
@@ -3805,10 +3920,9 @@ mod tests {
         let signal = left.zip(right).map(capture_output_vec).register(app.world_mut());
 
         app.update();
-        assert_eq!(
-            get_and_clear_output_vec::<(i32, i32)>(app.world_mut()),
-            vec![(1, 10), (1, 10)]
-        );
+        // With proper FRP semantics, each signal runs at most once per cycle.
+        // Zip uses a cache to accumulate inputs, then runs once to read the combined state.
+        assert_eq!(get_and_clear_output_vec::<(i32, i32)>(app.world_mut()), vec![(1, 10)]);
 
         app.update();
         assert_eq!(get_and_clear_output_vec::<(i32, i32)>(app.world_mut()), vec![(2, 10)]);
@@ -3930,8 +4044,8 @@ mod tests {
     fn test_flatten() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
-        let signal_1 = signal::from_system(|_: In<()>| 1);
-        let signal_2 = signal::from_system(|_: In<()>| 2);
+        let signal_1 = signal::from_system(|_: In<()>| 1).boxed_clone();
+        let signal_2 = signal::from_system(|_: In<()>| 2).boxed_clone();
 
         #[derive(Resource, Default)]
         struct SignalSelector(bool);
@@ -4030,8 +4144,8 @@ mod tests {
     fn test_switch() {
         let mut app = create_test_app();
         app.init_resource::<SignalOutput<i32>>();
-        let signal_1 = signal::from_system(|_: In<()>| 1);
-        let signal_2 = signal::from_system(|_: In<()>| 2);
+        let signal_1 = signal::from_system(|_: In<()>| 1).boxed_clone();
+        let signal_2 = signal::from_system(|_: In<()>| 2).boxed_clone();
 
         #[derive(Resource, Default)]
         struct SwitcherToggle(bool);
@@ -4060,16 +4174,16 @@ mod tests {
 
     // Ensure these helpers are also present in the tests module.
     #[derive(Resource, Default, Debug)]
-    struct SignalVecOutput<T: SSs + Clone + fmt::Debug>(Vec<VecDiff<T>>);
+    struct SignalVecOutput<T: Send + Sync + 'static + Clone + fmt::Debug>(Vec<VecDiff<T>>);
 
     fn capture_vec_output<T>(In(diffs): In<Vec<VecDiff<T>>>, mut output: ResMut<SignalVecOutput<T>>)
     where
-        T: SSs + Clone + fmt::Debug,
+        T: Send + Sync + 'static + Clone + fmt::Debug,
     {
         output.0.extend(diffs);
     }
 
-    fn get_and_clear_vec_output<T: SSs + Clone + fmt::Debug>(world: &mut World) -> Vec<VecDiff<T>> {
+    fn get_and_clear_vec_output<T: Send + Sync + 'static + Clone + fmt::Debug>(world: &mut World) -> Vec<VecDiff<T>> {
         world
             .get_resource_mut::<SignalVecOutput<T>>()
             .map(|mut res| core::mem::take(&mut res.0))
@@ -4310,21 +4424,21 @@ mod tests {
         #[derive(Resource, Default, core::fmt::Debug)]
         struct SignalMapOutput<K, V>(Vec<MapDiff<K, V>>)
         where
-            K: SSs + Clone + core::fmt::Debug,
-            V: SSs + Clone + core::fmt::Debug;
+            K: Send + Sync + 'static + Clone + core::fmt::Debug,
+            V: Send + Sync + 'static + Clone + core::fmt::Debug;
 
         fn capture_map_output<K, V>(In(diffs): In<Vec<MapDiff<K, V>>>, mut output: ResMut<SignalMapOutput<K, V>>)
         where
-            K: SSs + Clone + core::fmt::Debug,
-            V: SSs + Clone + core::fmt::Debug,
+            K: Send + Sync + 'static + Clone + core::fmt::Debug,
+            V: Send + Sync + 'static + Clone + core::fmt::Debug,
         {
             output.0.extend(diffs);
         }
 
         fn get_and_clear_map_output<K, V>(world: &mut World) -> Vec<MapDiff<K, V>>
         where
-            K: SSs + Clone + core::fmt::Debug,
-            V: SSs + Clone + core::fmt::Debug,
+            K: Send + Sync + 'static + Clone + core::fmt::Debug,
+            V: Send + Sync + 'static + Clone + core::fmt::Debug,
         {
             world
                 .get_resource_mut::<SignalMapOutput<K, V>>()
@@ -4454,21 +4568,21 @@ mod tests {
         #[derive(Resource, Default, core::fmt::Debug)]
         struct SignalMapOutput<K, V>(Vec<MapDiff<K, V>>)
         where
-            K: SSs + Clone + core::fmt::Debug,
-            V: SSs + Clone + core::fmt::Debug;
+            K: Send + Sync + 'static + Clone + core::fmt::Debug,
+            V: Send + Sync + 'static + Clone + core::fmt::Debug;
 
         fn capture_map_output<K, V>(In(diffs): In<Vec<MapDiff<K, V>>>, mut output: ResMut<SignalMapOutput<K, V>>)
         where
-            K: SSs + Clone + core::fmt::Debug,
-            V: SSs + Clone + core::fmt::Debug,
+            K: Send + Sync + 'static + Clone + core::fmt::Debug,
+            V: Send + Sync + 'static + Clone + core::fmt::Debug,
         {
             output.0.extend(diffs);
         }
 
         fn get_and_clear_map_output<K, V>(world: &mut World) -> Vec<MapDiff<K, V>>
         where
-            K: SSs + Clone + core::fmt::Debug,
-            V: SSs + Clone + core::fmt::Debug,
+            K: Send + Sync + 'static + Clone + core::fmt::Debug,
+            V: Send + Sync + 'static + Clone + core::fmt::Debug,
         {
             world
                 .get_resource_mut::<SignalMapOutput<K, V>>()
@@ -5420,7 +5534,7 @@ mod tests {
 
         // Test None variant - constant None
         app.world_mut().resource_mut::<SignalOutput<Option<i32>>>().0 = None;
-        let none_signal = crate::signal::option(None::<crate::signal::Source<i32>>)
+        let none_signal = crate::signal::option(None::<BoxedSignal<i32>>)
             .map(capture_output)
             .register(app.world_mut());
         app.update();
@@ -6130,4 +6244,83 @@ mod tests {
         app.update();
         assert_eq!(app.world().resource::<SignalOutput<Option<i32>>>().0, Some(None));
     }
+
+    #[test]
+    fn multi_schedule_chain_tags_correctly() {
+        use crate::graph::{SignalScheduleTag, Upstream};
+        use bevy_app::{PostUpdate, Update};
+        use bevy_ecs::schedule::ScheduleLabel;
+
+        let mut app = App::new();
+        app.add_plugins((
+            MinimalPlugins,
+            crate::JonmoPlugin::new::<PostUpdate>().with_schedule::<Update>(),
+        ));
+
+        // Build a chain: source -> map1 -> schedule::<Update> -> map2 -> schedule::<PostUpdate> -> map3
+        // Note: Scheduled doesn't create its own entity, it just tags its inner signal.
+        // So the actual entities are: source, map1 (tagged Update), map2 (tagged PostUpdate), map3
+        //
+        // Expected tags:
+        //   source: Update (tagged by schedule::<Update>'s upstream propagation)
+        //   map1: Update (caller of schedule::<Update>)
+        //   map2: PostUpdate (caller of schedule::<PostUpdate>, overwrites inherited Update)
+        //   map3: PostUpdate (inherits from map2's hint)
+
+        let handle = signal::from_system(|_: In<()>| Some(1i32))
+            .map_in(|x: i32| x + 1)
+            .schedule::<Update>()
+            .map_in(|x: i32| x * 2)
+            .schedule::<PostUpdate>()
+            .map_in(|x: i32| x - 1)
+            .register(app.world_mut());
+
+        // The handle points to map3 (the outermost signal)
+        let map3_entity = **handle;
+
+        // Walk upstream to find all entities
+        let world = app.world();
+
+        // map3 -> map2 -> map1 -> source
+        let map3_upstreams = world.get::<Upstream>(map3_entity).unwrap();
+        assert_eq!(map3_upstreams.len(), 1);
+        let map2_entity = **map3_upstreams.iter().next().unwrap();
+
+        let map2_upstreams = world.get::<Upstream>(map2_entity).unwrap();
+        assert_eq!(map2_upstreams.len(), 1);
+        let map1_entity = **map2_upstreams.iter().next().unwrap();
+
+        let map1_upstreams = world.get::<Upstream>(map1_entity).unwrap();
+        assert_eq!(map1_upstreams.len(), 1);
+        let source_entity = **map1_upstreams.iter().next().unwrap();
+
+        // Verify schedule tags
+        let source_tag = world.get::<SignalScheduleTag>(source_entity);
+        assert!(source_tag.is_some(), "source should have a schedule tag");
+        assert_eq!(source_tag.unwrap().0, Update.intern(), "source should be tagged Update");
+
+        let map1_tag = world.get::<SignalScheduleTag>(map1_entity);
+        assert!(map1_tag.is_some(), "map1 should have a schedule tag");
+        assert_eq!(
+            map1_tag.unwrap().0,
+            Update.intern(),
+            "map1 should be tagged Update (caller of schedule::<Update>)"
+        );
+
+        let map2_tag = world.get::<SignalScheduleTag>(map2_entity);
+        assert!(map2_tag.is_some(), "map2 should have a schedule tag");
+        assert_eq!(
+            map2_tag.unwrap().0,
+            PostUpdate.intern(),
+            "map2 should be tagged PostUpdate (caller of schedule::<PostUpdate>)"
+        );
+
+        let map3_tag = world.get::<SignalScheduleTag>(map3_entity);
+        assert!(map3_tag.is_some(), "map3 should have a schedule tag");
+        assert_eq!(
+            map3_tag.unwrap().0,
+            PostUpdate.intern(),
+            "map3 should inherit PostUpdate"
+        );
+    }
 }
diff --git a/src/signal_map.rs b/src/signal_map.rs
index c16ff81..a209546 100644
--- a/src/signal_map.rs
+++ b/src/signal_map.rs
@@ -1,17 +1,26 @@
-//! Data structures and combinators for constructing reactive [`System`] dependency graphs on top of
-//! [`BTreeMap`] mutations, see [`MutableBTreeMap`] and [`SignalMapExt`].
+//! Data structures and combinators for constructing reactive [`System`] dependency graphs on top
+//! of [`BTreeMap`] mutations.
+//!
+//! This module provides [`SignalMap`], a collection-oriented signal trait with **diff-based
+//! semantics**. Rather than forwarding entire maps each frame, [`SignalMap`] propagates
+//! [`MapDiff`] values that describe incremental mutations (insert, update, remove, etc.). This
+//! enables efficient, constant-time reactive updates for keyed collections of any size.
+//!
+//! See [`MutableBTreeMap`] for the primary source type and [`SignalMapExt`] for available
+//! combinators. For the general signal graph runtime model and core concepts, see the [`Signal`]
+//! trait documentation.
 use super::{
     graph::{
-        LazySignal, SignalHandle, SignalHandles, SignalSystem, downcast_any_clone, lazy_signal_from_system,
-        pipe_signal, poll_signal, process_signals, register_signal,
+        LazySignal, SignalHandle, SignalHandles, SignalSystem, apply_schedule_to_signal, downcast_any_clone,
+        lazy_signal_from_system, pipe_signal, poll_signal, register_signal, trigger_signal_subgraph,
     },
     signal::{self, Signal, SignalExt},
     signal_vec::{ReplayOnce, Replayable, SignalVec, VecDiff},
-    utils::{LazyEntity, SSs},
+    utils::LazyEntity,
 };
 use crate::prelude::clone;
 use alloc::collections::BTreeMap;
-use bevy_ecs::{entity_disabling::Internal, prelude::*};
+use bevy_ecs::{entity_disabling::Internal, prelude::*, schedule::ScheduleLabel};
 use bevy_platform::{
     prelude::*,
     sync::{Arc, LazyLock, Mutex},
@@ -107,10 +116,22 @@ impl<K, V> MapDiff<K, V> {
     }
 }
 
-/// Monadic registration facade for structs that encapsulate some [`System`] which is a valid member
-/// of the signal graph downstream of some source [`MutableBTreeMap`]; this is similar to [`Signal`]
-/// but critically requires that the [`System`] outputs [`Option<MapDiff<Self::Key, Self::Value>>`].
-pub trait SignalMap: SSs {
+/// A composable node in [jonmo](crate)'s reactive dependency graph, specialized for **diff-based**
+/// [`BTreeMap`] reactivity.
+///
+/// Unlike [`Signal`] which forwards complete values, a [`SignalMap`] propagates [`MapDiff`]
+/// values describing incremental mutations to an underlying keyed collection. This diff-based
+/// approach enables **constant-time reactive updates** regardless of map size; only the changes
+/// are transmitted and processed, not the entire map.
+///
+/// Downstream consumers receive a stream of [`MapDiff`] variants ([`Insert`](MapDiff::Insert),
+/// [`Update`](MapDiff::Update), [`Remove`](MapDiff::Remove), etc.) that they can apply to
+/// maintain a synchronized view of the source data.
+///
+/// For the general signal graph runtime model, registration pattern, flow control semantics, and
+/// composition strategies, see the [`Signal`] trait documentation, which also applies to
+/// [`SignalMap`].
+pub trait SignalMap: Send + Sync + 'static {
     #[allow(missing_docs)]
     type Key;
     #[allow(missing_docs)]
@@ -245,7 +266,7 @@ impl<Upstream, S: Signal> SignalMap for MapValueSignal<Upstream, S>
 where
     Upstream: SignalMap,
     S: Signal + 'static,
-    S::Item: Clone + SSs,
+    S::Item: Clone + Send + Sync + 'static,
 {
     type Key = Upstream::Key;
     type Value = S::Item;
@@ -532,11 +553,11 @@ pub trait SignalMapExt: SignalMap {
     fn for_each<O, IOO, F, M>(self, system: F) -> ForEach<Self, O>
     where
         Self: Sized,
-        Self::Key: 'static,
-        Self::Value: 'static,
-        O: Clone + 'static,
+        Self::Key: Send + Sync + 'static,
+        Self::Value: Send + Sync + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        F: IntoSystem<In<Vec<MapDiff<Self::Key, Self::Value>>>, IOO, M> + SSs,
+        F: IntoSystem<In<Vec<MapDiff<Self::Key, Self::Value>>>, IOO, M> + Send + Sync + 'static,
     {
         ForEach {
             upstream: self,
@@ -564,10 +585,10 @@ pub trait SignalMapExt: SignalMap {
     fn map_value<O, F, M>(self, system: F) -> MapValue<Self, O>
     where
         Self: Sized,
-        Self::Key: Clone + 'static,
-        Self::Value: 'static,
-        O: Clone + 'static,
-        F: IntoSystem<In<Self::Value>, O, M> + SSs,
+        Self::Key: Clone + Send + Sync + 'static,
+        Self::Value: Send + Sync + 'static,
+        O: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<Self::Value>, O, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let system_id = world.register_system(system);
@@ -612,11 +633,11 @@ pub trait SignalMapExt: SignalMap {
     fn map_value_signal<S, F, M>(self, system: F) -> MapValueSignal<Self, S>
     where
         Self: Sized,
-        Self::Key: Ord + Clone + SSs,
-        Self::Value: 'static,
+        Self::Key: Ord + Clone + Send + Sync + Send + Sync + 'static,
+        Self::Value: Send + Sync + 'static,
         S: Signal + Clone + 'static,
-        S::Item: Clone + SSs,
-        F: IntoSystem<In<Self::Value>, S, M> + SSs,
+        S::Item: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<Self::Value>, S, M> + Send + Sync + 'static,
     {
         #[derive(Component)]
         struct QueuedMapDiffs<K, V>(Vec<MapDiff<K, V>>);
@@ -637,7 +658,7 @@ pub trait SignalMapExt: SignalMap {
             .register(world);
             output_signal_entity.set(*output_signal);
 
-            fn spawn_processor<K: Clone + SSs, V: Clone + SSs>(
+            fn spawn_processor<K: Clone + Send + Sync + 'static, V: Clone + Send + Sync + 'static>(
                 world: &mut World,
                 output_signal: SignalSystem,
                 key: K,
@@ -659,7 +680,7 @@ pub trait SignalMapExt: SignalMap {
                                 key: key.clone(),
                                 value,
                             });
-                        process_signals(world, [output_signal], Box::new(()));
+                        trigger_signal_subgraph(world, [output_signal], Box::new(()));
                     })
                     .register(world);
                 (processor_handle, *inner_signal_id, initial_value)
@@ -786,7 +807,7 @@ pub trait SignalMapExt: SignalMap {
                         .0
                         .extend(new_map_diffs);
                 }
-                process_signals(world, [output_signal], Box::new(()));
+                trigger_signal_subgraph(world, [output_signal], Box::new(()));
             };
             let manager_handle = self.for_each(manager_system_logic).register(world);
             world
@@ -828,8 +849,8 @@ pub trait SignalMapExt: SignalMap {
     fn key(self, key: Self::Key) -> Key<Self>
     where
         Self: Sized,
-        Self::Key: PartialEq + SSs,
-        Self::Value: Clone + Send + 'static,
+        Self::Key: PartialEq + Send + Sync + Send + Sync + 'static,
+        Self::Value: Clone + Send + Sync + 'static,
     {
         Key {
             inner: self.for_each(
@@ -893,8 +914,8 @@ pub trait SignalMapExt: SignalMap {
     fn debug(self) -> Debug<Self>
     where
         Self: Sized,
-        Self::Key: fmt::Debug + Clone + 'static,
-        Self::Value: fmt::Debug + Clone + 'static,
+        Self::Key: fmt::Debug + Clone + Send + Sync + 'static,
+        Self::Value: fmt::Debug + Clone + Send + Sync + 'static,
     {
         let location = core::panic::Location::caller();
         Debug {
@@ -976,6 +997,22 @@ pub trait SignalMapExt: SignalMap {
         Box::new(self)
     }
 
+    /// Assign a schedule to this signal map chain, see [`SignalExt::schedule`].
+    fn schedule<Sched: ScheduleLabel + Default + 'static>(self) -> ScheduledMap<Sched, Self::Key, Self::Value>
+    where
+        Self: Sized + 'static,
+    {
+        let signal = LazySignal::new(move |world: &mut World| {
+            let handle = self.register_signal_map(world);
+            apply_schedule_to_signal(world, *handle, Sched::default().intern());
+            *handle
+        });
+        ScheduledMap {
+            signal,
+            _marker: PhantomData,
+        }
+    }
+
     /// Activate this [`SignalMap`] and all its upstreams, causing them to be evaluated every frame
     /// until they are [`SignalHandle::cleanup`]-ed, see [`SignalHandle`].
     fn register(self, world: &mut World) -> SignalHandle
@@ -988,6 +1025,32 @@ pub trait SignalMapExt: SignalMap {
 
 impl<T: ?Sized> SignalMapExt for T where T: SignalMap {}
 
+/// Signal map node wrapper that assigns a schedule to a signal chain, see
+/// [`.schedule`](SignalMapExt::schedule).
+pub struct ScheduledMap<Sched, K, V> {
+    signal: LazySignal,
+    #[allow(clippy::type_complexity)]
+    _marker: PhantomData<fn() -> (Sched, K, V)>,
+}
+
+impl<Sched, K, V> Clone for ScheduledMap<Sched, K, V> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<Sched: 'static, K: Send + Sync + 'static, V: Send + Sync + 'static> SignalMap for ScheduledMap<Sched, K, V> {
+    type Key = K;
+    type Value = V;
+
+    fn register_boxed_signal_map(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.signal.register(world).into()
+    }
+}
+
 static STALE_MUTABLE_BTREE_MAPS: LazyLock<Mutex<Vec<Entity>>> = LazyLock::new(Mutex::default);
 
 pub(crate) fn despawn_stale_mutable_btree_maps(world: &mut World) {
@@ -1157,8 +1220,8 @@ impl Replayable for MapReplayTrigger {
 
 fn new_mutable_btree_map_data<K, V>(map: BTreeMap<K, V>) -> (MutableBTreeMapData<K, V>, LazyEntity)
 where
-    K: Ord + Clone + SSs,
-    V: Clone + SSs,
+    K: Ord + Clone + Send + Sync + 'static,
+    V: Clone + Send + Sync + 'static,
 {
     let data_entity = LazyEntity::new();
     let broadcaster = LazySignal::new(clone!((data_entity) move |world: &mut World| {
@@ -1184,7 +1247,7 @@ where
 }
 
 impl<K, V> MutableBTreeMap<K, V> {
-    /// Creates a [`Builder`] for constructing a [`MutableBTreeMap`].
+    /// Creates a [`MutableBTreeMapBuilder`] for constructing a [`MutableBTreeMap`].
     ///
     /// # Example
     ///
@@ -1206,8 +1269,8 @@ impl<K, V> MutableBTreeMap<K, V> {
     ///     })
     ///     .spawn(&mut world);
     /// ```
-    pub fn builder() -> Builder<K, V> {
-        Builder::new()
+    pub fn builder() -> MutableBTreeMapBuilder<K, V> {
+        MutableBTreeMapBuilder::new()
     }
 
     /// Provides read-only access to the underlying [`BTreeMap`] via either a `&World` or a
@@ -1217,8 +1280,8 @@ impl<K, V> MutableBTreeMap<K, V> {
         mutable_btree_map_data_reader: impl ReadMutableBTreeMapData<'s, K, V>,
     ) -> MutableBTreeMapReadGuard<'s, K, V>
     where
-        K: SSs,
-        V: SSs,
+        K: Send + Sync + 'static,
+        V: Send + Sync + 'static,
     {
         MutableBTreeMapReadGuard {
             guard: mutable_btree_map_data_reader.read(self.entity),
@@ -1232,8 +1295,8 @@ impl<K, V> MutableBTreeMap<K, V> {
         mutable_btree_map_data_writer: impl WriteMutableBTreeMapData<'w, K, V>,
     ) -> MutableBTreeMapWriteGuard<'w, K, V>
     where
-        K: SSs,
-        V: SSs,
+        K: Send + Sync + 'static,
+        V: Send + Sync + 'static,
     {
         MutableBTreeMapWriteGuard {
             guard: mutable_btree_map_data_writer.write(self.entity),
@@ -1243,8 +1306,8 @@ impl<K, V> MutableBTreeMap<K, V> {
     /// Returns a [`Source`] signal from this [`MutableBTreeMap`].
     pub fn signal_map(&self) -> Source<K, V>
     where
-        K: Clone + Ord + SSs,
-        V: Clone + SSs,
+        K: Clone + Ord + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
     {
         let replay_lazy_signal = LazySignal::new(clone!((self => self_) move |world: &mut World| {
             let broadcaster_system = world.get::<MutableBTreeMapData<K, V>>(self_.entity).unwrap().broadcaster.clone().register(world);
@@ -1275,7 +1338,7 @@ impl<K, V> MutableBTreeMap<K, V> {
             replay_entity.set(*replay_signal);
 
             let trigger = Box::new(move |world: &mut World| {
-                process_signals(world, [replay_signal], Box::new(Vec::<MapDiff<K, V>>::new()));
+                trigger_signal_subgraph(world, [replay_signal], Box::new(Vec::<MapDiff<K, V>>::new()));
             });
 
             world.entity_mut(*replay_signal).insert((MapReplayTrigger(trigger), ReplayOnce));
@@ -1294,8 +1357,8 @@ impl<K, V> MutableBTreeMap<K, V> {
     /// sorted order.
     pub fn signal_vec_keys(&self) -> SignalVecKeys<K>
     where
-        K: Ord + Clone + SSs,
-        V: Clone + SSs,
+        K: Ord + Clone + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
     {
         let upstream = self.signal_map();
         let lazy_signal = LazySignal::new(move |world: &mut World| {
@@ -1345,8 +1408,8 @@ impl<K, V> MutableBTreeMap<K, V> {
     /// order.
     pub fn signal_vec_entries(&self) -> SignalVecEntries<K, V>
     where
-        K: Ord + Clone + SSs,
-        V: Clone + SSs,
+        K: Ord + Clone + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
     {
         let upstream = self.signal_map();
         let lazy_signal = LazySignal::new(move |world: &mut World| {
@@ -1403,8 +1466,8 @@ impl<K, V> MutableBTreeMap<K, V> {
 
 impl<K, V> From<&mut World> for MutableBTreeMap<K, V>
 where
-    K: Ord + Clone + SSs,
-    V: Clone + SSs,
+    K: Ord + Clone + Send + Sync + 'static,
+    V: Clone + Send + Sync + 'static,
 {
     fn from(world: &mut World) -> Self {
         let (data, data_entity) = new_mutable_btree_map_data::<K, V>(BTreeMap::new());
@@ -1420,8 +1483,8 @@ where
 
 impl<K, V> FromWorld for MutableBTreeMap<K, V>
 where
-    K: Ord + Clone + SSs,
-    V: Clone + SSs,
+    K: Ord + Clone + Send + Sync + 'static,
+    V: Clone + Send + Sync + 'static,
 {
     fn from_world(world: &mut World) -> Self {
         world.into()
@@ -1441,22 +1504,22 @@ where
 ///     .values([(1, "one"), (2, "two")])
 ///     .spawn(&mut world);
 /// ```
-pub struct Builder<K, V>(BTreeMap<K, V>);
+pub struct MutableBTreeMapBuilder<K, V>(BTreeMap<K, V>);
 
-impl<K, V> Default for Builder<K, V> {
+impl<K, V> Default for MutableBTreeMapBuilder<K, V> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<K, V> Builder<K, V> {
+impl<K, V> MutableBTreeMapBuilder<K, V> {
     /// Creates a new empty builder.
     pub fn new() -> Self {
         Self(BTreeMap::new())
     }
 }
 
-impl<K: Ord, V> Builder<K, V> {
+impl<K: Ord, V> MutableBTreeMapBuilder<K, V> {
     /// Sets the initial values of the [`MutableBTreeMap`].
     ///
     /// # Example
@@ -1497,7 +1560,7 @@ impl<K: Ord, V> Builder<K, V> {
     }
 }
 
-impl<K, V, A> From<A> for Builder<K, V>
+impl<K, V, A> From<A> for MutableBTreeMapBuilder<K, V>
 where
     BTreeMap<K, V>: From<A>,
 {
@@ -1506,10 +1569,10 @@ where
     }
 }
 
-impl<K, V> Builder<K, V>
+impl<K, V> MutableBTreeMapBuilder<K, V>
 where
-    K: Ord + Clone + SSs,
-    V: Clone + SSs,
+    K: Ord + Clone + Send + Sync + 'static,
+    V: Clone + Send + Sync + 'static,
 {
     /// Spawns a [`MutableBTreeMap`] using a `&mut World`.
     pub fn spawn(self, world: &mut World) -> MutableBTreeMap<K, V> {
@@ -1538,8 +1601,8 @@ where
 
 impl<K, V> From<&mut Commands<'_, '_>> for MutableBTreeMap<K, V>
 where
-    K: Ord + Clone + SSs,
-    V: Clone + SSs,
+    K: Ord + Clone + Send + Sync + 'static,
+    V: Clone + Send + Sync + 'static,
 {
     fn from(commands: &mut Commands) -> Self {
         let (data, data_entity) = new_mutable_btree_map_data::<K, V>(BTreeMap::new());
@@ -1565,8 +1628,8 @@ where
 
 impl<'s, K, V> ReadMutableBTreeMapData<'s, K, V> for &'s Query<'_, 's, &MutableBTreeMapData<K, V>>
 where
-    K: SSs,
-    V: SSs,
+    K: Send + Sync + 'static,
+    V: Send + Sync + 'static,
 {
     fn read(self, entity: Entity) -> &'s MutableBTreeMapData<K, V> {
         self.get(entity).unwrap()
@@ -1575,8 +1638,8 @@ where
 
 impl<'s, K, V> ReadMutableBTreeMapData<'s, K, V> for &'s World
 where
-    K: SSs,
-    V: SSs,
+    K: Send + Sync + 'static,
+    V: Send + Sync + 'static,
 {
     fn read(self, entity: Entity) -> &'s MutableBTreeMapData<K, V> {
         self.get(entity).unwrap()
@@ -1595,8 +1658,8 @@ where
 
 impl<'a, 'w, 's, K, V> WriteMutableBTreeMapData<'a, K, V> for &'a mut Query<'w, 's, &mut MutableBTreeMapData<K, V>>
 where
-    K: SSs,
-    V: SSs,
+    K: Send + Sync + 'static,
+    V: Send + Sync + 'static,
 {
     fn write(self, entity: Entity) -> Mut<'a, MutableBTreeMapData<K, V>> {
         self.get_mut(entity).unwrap()
@@ -1605,8 +1668,8 @@ where
 
 impl<'w, K, V> WriteMutableBTreeMapData<'w, K, V> for &'w mut World
 where
-    K: SSs,
-    V: SSs,
+    K: Send + Sync + 'static,
+    V: Send + Sync + 'static,
 {
     fn write(self, entity: Entity) -> Mut<'w, MutableBTreeMapData<K, V>> {
         self.get_mut(entity).unwrap()
@@ -1623,15 +1686,15 @@ pub(crate) mod tests {
     #[derive(Resource, Default, Debug)]
     struct SignalMapOutput<K, V>(Vec<MapDiff<K, V>>)
     where
-        K: SSs + Clone + fmt::Debug,
-        V: SSs + Clone + fmt::Debug;
+        K: Send + Sync + 'static + Clone + fmt::Debug,
+        V: Send + Sync + 'static + Clone + fmt::Debug;
 
     // Helper system that captures incoming diffs and stores them in the
     // SignalMapOutput resource.
     fn capture_map_output<K, V>(In(diffs): In<Vec<MapDiff<K, V>>>, mut output: ResMut<SignalMapOutput<K, V>>)
     where
-        K: SSs + Clone + fmt::Debug,
-        V: SSs + Clone + fmt::Debug,
+        K: Send + Sync + 'static + Clone + fmt::Debug,
+        V: Send + Sync + 'static + Clone + fmt::Debug,
     {
         output.0.extend(diffs);
     }
@@ -1640,8 +1703,8 @@ pub(crate) mod tests {
     // it easy to assert against the output of a single frame's update.
     fn get_and_clear_map_output<K, V>(world: &mut World) -> Vec<MapDiff<K, V>>
     where
-        K: SSs + Clone + fmt::Debug,
-        V: SSs + Clone + fmt::Debug,
+        K: Send + Sync + 'static + Clone + fmt::Debug,
+        V: Send + Sync + 'static + Clone + fmt::Debug,
     {
         world
             .get_resource_mut::<SignalMapOutput<K, V>>()
@@ -2017,24 +2080,24 @@ pub(crate) mod tests {
     #[derive(Resource, Default, Debug)]
     struct SignalOutput<T>(Option<T>)
     where
-        T: SSs + Clone + fmt::Debug;
+        T: Send + Sync + 'static + Clone + fmt::Debug;
 
     // Helper system that captures incoming values and stores them in the SignalOutput
     // resource.
     fn capture_output<T>(In(value): In<T>, mut output: ResMut<SignalOutput<T>>)
     where
-        T: SSs + Clone + fmt::Debug,
+        T: Send + Sync + 'static + Clone + fmt::Debug,
     {
         output.0 = Some(value);
     }
 
     // Helper to retrieve the last captured value.
-    fn get_output<T: SSs + Clone + fmt::Debug>(world: &mut World) -> Option<T> {
+    fn get_output<T: Send + Sync + 'static + Clone + fmt::Debug>(world: &mut World) -> Option<T> {
         world.get_resource::<SignalOutput<T>>().and_then(|res| res.0.clone())
     }
 
     // Helper to clear the output, useful for testing no-emission cases.
-    fn clear_output<T: SSs + Clone + fmt::Debug>(world: &mut World) {
+    fn clear_output<T: Send + Sync + 'static + Clone + fmt::Debug>(world: &mut World) {
         if let Some(mut res) = world.get_resource_mut::<SignalOutput<T>>() {
             res.0 = None;
         }
@@ -2135,16 +2198,16 @@ pub(crate) mod tests {
     }
 
     #[derive(Resource, Default, Debug)]
-    struct SignalVecOutput<T: SSs + Clone + fmt::Debug>(Vec<VecDiff<T>>);
+    struct SignalVecOutput<T: Send + Sync + 'static + Clone + fmt::Debug>(Vec<VecDiff<T>>);
 
     fn capture_vec_output<T>(In(diffs): In<Vec<VecDiff<T>>>, mut output: ResMut<SignalVecOutput<T>>)
     where
-        T: SSs + Clone + fmt::Debug,
+        T: Send + Sync + 'static + Clone + fmt::Debug,
     {
         output.0.extend(diffs);
     }
 
-    fn get_and_clear_vec_output<T: SSs + Clone + fmt::Debug>(world: &mut World) -> Vec<VecDiff<T>> {
+    fn get_and_clear_vec_output<T: Send + Sync + 'static + Clone + fmt::Debug>(world: &mut World) -> Vec<VecDiff<T>> {
         world
             .get_resource_mut::<SignalVecOutput<T>>()
             .map(|mut res| core::mem::take(&mut res.0))
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index 6c77606..20ff036 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -1,16 +1,27 @@
-//! Data structures and combinators for constructing reactive [`System`] dependency graphs on top of
-//! [`Vec`] mutations, see [`MutableVec`] and [`SignalVecExt`].
+//! Data structures and combinators for constructing reactive [`System`] dependency graphs on top
+//! of [`Vec`] mutations.
+//!
+//! This module provides [`SignalVec`], a collection-oriented signal trait with **diff-based
+//! semantics**. Rather than forwarding entire collections each frame, [`SignalVec`] propagates
+//! [`VecDiff`] values that describe incremental mutations (insert, remove, update, move, etc.).
+//! This enables efficient, constant-time reactive updates for collections of any size.
+//!
+//! See [`MutableVec`] for the primary source type and [`SignalVecExt`] for available combinators.
+//! For the general signal graph runtime model and core concepts, see the [`Signal`] trait
+//! documentation.
 use super::{
     graph::{
-        LazySignal, SignalHandle, SignalHandles, SignalSystem, Upstream, downcast_any_clone, lazy_signal_from_system,
-        pipe_signal, poll_signal, process_signals, register_signal,
+        LazySignal, SignalHandle, SignalHandles, SignalSystem, Upstream, apply_schedule_to_signal, downcast_any_clone,
+        lazy_signal_from_system, pipe_signal, poll_signal, register_signal, trigger_signal_subgraph,
     },
-    signal::{self, Signal, SignalExt},
-    utils::{LazyEntity, SSs},
+    signal::{self, BoxedSignal, Signal, SignalExt},
+    utils::LazyEntity,
 };
 use crate::prelude::clone;
 use bevy_derive::{Deref, DerefMut};
-use bevy_ecs::{change_detection::Mut, entity_disabling::Internal, prelude::*, system::SystemId};
+use bevy_ecs::{
+    change_detection::Mut, entity_disabling::Internal, prelude::*, schedule::ScheduleLabel, system::SystemId,
+};
 use bevy_platform::{
     collections::{HashMap, HashSet},
     prelude::*,
@@ -127,10 +138,22 @@ impl<T> VecDiff<T> {
     }
 }
 
-/// Monadic registration facade for structs that encapsulate some [`System`] which is a valid member
-/// of the signal graph downstream of some source [`MutableVec`]; this is similar to [`Signal`] but
-/// critically requires that the [`System`] outputs [`Option<VecDiff<Self::Item>>`].
-pub trait SignalVec: SSs {
+/// A composable node in [jonmo](crate)'s reactive dependency graph, specialized for **diff-based**
+/// [`Vec`] reactivity.
+///
+/// Unlike [`Signal`] which forwards complete values, a [`SignalVec`] propagates [`VecDiff`]
+/// values describing incremental mutations to an underlying collection. This diff-based approach
+/// enables **constant-time reactive updates** regardless of collection size; only the changes are
+/// transmitted and processed, not the entire collection.
+///
+/// Downstream consumers receive a stream of [`VecDiff`] variants ([`InsertAt`](VecDiff::InsertAt),
+/// [`RemoveAt`](VecDiff::RemoveAt), [`UpdateAt`](VecDiff::UpdateAt), [`Move`](VecDiff::Move),
+/// etc.) that they can apply to maintain a synchronized view of the source data.
+///
+/// For the general signal graph runtime model, registration pattern, flow control semantics, and
+/// composition strategies, see the [`Signal`] trait documentation, which also applies to
+/// [`SignalVec`].
+pub trait SignalVec: Send + Sync + 'static {
     /// Output type.
     type Item;
 
@@ -287,7 +310,7 @@ impl<Upstream, S: Signal> SignalVec for MapSignal<Upstream, S>
 where
     Upstream: SignalVec,
     S: Signal + 'static,
-    S::Item: Clone + SSs,
+    S::Item: Clone + Send + Sync + 'static,
 {
     type Item = S::Item;
 
@@ -562,7 +585,7 @@ impl<Upstream> SignalVec for Enumerate<Upstream>
 where
     Upstream: SignalVec,
 {
-    type Item = (super::signal::Source<Option<usize>>, Upstream::Item);
+    type Item = (BoxedSignal<Option<usize>>, Upstream::Item);
 
     fn register_boxed_signal_vec(self: Box<Self>, world: &mut World) -> SignalHandle {
         self.signal.register(world).into()
@@ -697,23 +720,13 @@ where
     }
 }
 
+/// Tagged diff for chain combinator to distinguish left vs right upstream.
+#[derive(Clone)]
 enum LrDiff<T> {
     Left(Vec<VecDiff<T>>),
     Right(Vec<VecDiff<T>>),
 }
 
-impl<T> Clone for LrDiff<T>
-where
-    T: Clone,
-{
-    fn clone(&self) -> Self {
-        match self {
-            Self::Left(left) => Self::Left(left.clone()),
-            Self::Right(right) => Self::Right(right.clone()),
-        }
-    }
-}
-
 /// Signal graph node which concatenates its upstreams, see [`.chain`](SignalVecExt::chain).
 pub struct Chain<Left, Right>
 where
@@ -747,12 +760,12 @@ where
     type Item = Left::Item;
 
     fn register_boxed_signal_vec(self: Box<Self>, world: &mut World) -> SignalHandle {
+        let signal = self.signal.register(world);
         let SignalHandle(left_upstream) = self.left_wrapper.register(world);
         let SignalHandle(right_upstream) = self.right_wrapper.register(world);
-        let signal = self.signal.register(world);
         pipe_signal(world, left_upstream, signal);
         pipe_signal(world, right_upstream, signal);
-        signal.into()
+        SignalHandle(signal)
     }
 }
 
@@ -879,7 +892,7 @@ impl<Upstream> SignalVec for Flatten<Upstream>
 where
     Upstream: SignalVec,
     Upstream::Item: SignalVec + 'static,
-    <Upstream::Item as SignalVec>::Item: Clone + SSs,
+    <Upstream::Item as SignalVec>::Item: Clone + Send + Sync + 'static,
 {
     type Item = <Upstream::Item as SignalVec>::Item;
 
@@ -1069,10 +1082,10 @@ pub trait SignalVecExt: SignalVec {
     fn for_each<O, IOO, F, M>(self, system: F) -> ForEach<Self, O>
     where
         Self: Sized,
-        Self::Item: 'static,
-        O: Clone + 'static,
+        Self::Item: Send + Sync + 'static,
+        O: Clone + Send + Sync + 'static,
         IOO: Into<Option<O>> + 'static,
-        F: IntoSystem<In<Vec<VecDiff<Self::Item>>>, IOO, M> + SSs,
+        F: IntoSystem<In<Vec<VecDiff<Self::Item>>>, IOO, M> + Send + Sync + 'static,
     {
         ForEach {
             upstream: self,
@@ -1099,9 +1112,9 @@ pub trait SignalVecExt: SignalVec {
     fn map<O, F, M>(self, system: F) -> Map<Self, O>
     where
         Self: Sized,
-        Self::Item: 'static,
-        O: Clone + 'static,
-        F: IntoSystem<In<Self::Item>, O, M> + SSs,
+        Self::Item: Send + Sync + 'static,
+        O: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<Self::Item>, O, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let system = world.register_system(system);
@@ -1183,9 +1196,9 @@ pub trait SignalVecExt: SignalVec {
     fn map_in<O, F>(self, mut function: F) -> Map<Self, O>
     where
         Self: Sized,
-        Self::Item: 'static,
-        O: Clone + 'static,
-        F: FnMut(Self::Item) -> O + SSs,
+        Self::Item: Send + Sync + 'static,
+        O: Clone + Send + Sync + 'static,
+        F: FnMut(Self::Item) -> O + Send + Sync + 'static,
     {
         self.map(move |In(item)| function(item))
     }
@@ -1212,9 +1225,9 @@ pub trait SignalVecExt: SignalVec {
     fn map_in_ref<O, F>(self, mut function: F) -> Map<Self, O>
     where
         Self: Sized,
-        Self::Item: 'static,
-        O: Clone + 'static,
-        F: FnMut(&Self::Item) -> O + SSs,
+        Self::Item: Send + Sync + 'static,
+        O: Clone + Send + Sync + 'static,
+        F: FnMut(&Self::Item) -> O + Send + Sync + 'static,
     {
         self.map(move |In(item)| function(&item))
     }
@@ -1239,15 +1252,15 @@ pub trait SignalVecExt: SignalVec {
     fn map_signal<S, F, M>(self, system: F) -> MapSignal<Self, S>
     where
         Self: Sized,
-        Self::Item: SSs,
+        Self::Item: Send + Sync + 'static,
         S: Signal + 'static + Clone,
         S::Item: Clone + Send + Sync,
-        F: IntoSystem<In<Self::Item>, S, M> + SSs,
+        F: IntoSystem<In<Self::Item>, S, M> + Send + Sync + 'static,
     {
         #[derive(Component, Deref, DerefMut, Clone, Copy)]
         struct ItemIndex(usize);
 
-        fn spawn_processor<Item: Clone + SSs, S: Signal<Item = Item> + Clone + 'static>(
+        fn spawn_processor<Item: Clone + Send + Sync + 'static, S: Signal<Item = Item> + Clone + 'static>(
             world: &mut World,
             output_signal: SignalSystem,
             index: usize,
@@ -1270,7 +1283,7 @@ pub trait SignalVecExt: SignalVec {
                         index: current_index,
                         value,
                     });
-                process_signals(world, [output_signal], Box::new(()));
+                trigger_signal_subgraph(world, [output_signal], Box::new(()));
             });
             let processor_handle = inner_signal.map(processor_logic).register(world);
             processor_entity.set(**processor_handle);
@@ -1474,7 +1487,7 @@ pub trait SignalVecExt: SignalVec {
                         .unwrap()
                         .0
                         .extend(new_diffs);
-                    process_signals(world, [output_signal], Box::new(()));
+                    trigger_signal_subgraph(world, [output_signal], Box::new(()));
                 }
             };
             let manager_handle = self.for_each(manager_system_logic).register(world);
@@ -1517,8 +1530,8 @@ pub trait SignalVecExt: SignalVec {
     fn filter<F, M>(self, predicate: F) -> Filter<Self>
     where
         Self: Sized,
-        Self::Item: Clone + 'static,
-        F: IntoSystem<In<Self::Item>, bool, M> + SSs,
+        Self::Item: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<Self::Item>, bool, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let system = world.register_system(predicate);
@@ -1558,9 +1571,9 @@ pub trait SignalVecExt: SignalVec {
     fn filter_map<O, F, M>(self, system: F) -> FilterMap<Self, O>
     where
         Self: Sized,
-        Self::Item: 'static,
-        O: Clone + 'static,
-        F: IntoSystem<In<Self::Item>, Option<O>, M> + SSs,
+        Self::Item: Send + Sync + 'static,
+        O: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<Self::Item>, Option<O>, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let system = world.register_system(system);
@@ -1605,9 +1618,9 @@ pub trait SignalVecExt: SignalVec {
     fn filter_signal<F, S, M>(self, system: F) -> FilterSignal<Self>
     where
         Self: Sized,
-        Self::Item: Clone + SSs,
+        Self::Item: Clone + Send + Sync + 'static,
         S: Signal<Item = bool> + 'static,
-        F: IntoSystem<In<Self::Item>, S, M> + SSs,
+        F: IntoSystem<In<Self::Item>, S, M> + Send + Sync + 'static,
     {
         struct FilterSignalItem<T> {
             signal: SignalHandle,
@@ -1621,7 +1634,7 @@ pub trait SignalVecExt: SignalVec {
             diffs: Vec<VecDiff<T>>,
         }
 
-        fn with_filter_signal_data<T: SSs, O>(
+        fn with_filter_signal_data<T: Send + Sync + 'static, O>(
             world: &mut World,
             entity: Entity,
             f: impl FnOnce(Mut<FilterSignalData<T>>) -> O,
@@ -1637,7 +1650,7 @@ pub trait SignalVecExt: SignalVec {
         #[derive(Component, Deref, DerefMut)]
         struct FilterSignalIndex(usize);
 
-        fn spawn_filter_signal<T: Clone + SSs>(
+        fn spawn_filter_signal<T: Clone + Send + Sync + 'static>(
             world: &mut World,
             index: usize,
             signal: impl Signal<Item = bool> + 'static,
@@ -1647,18 +1660,22 @@ pub trait SignalVecExt: SignalVec {
             let processor_system = clone!((entity) move |In(filter): In<bool>, world: &mut World| {
                 let self_entity = *entity;
 
-                let item_index = world
+                let Some(item_index) = world
                     .query_filtered::<&FilterSignalIndex, Allow<Internal>>()
                     .get(world, self_entity)
-                    .unwrap()
-                    .0;
-                let mut filter_signal_data = world
+                    .ok()
+                    .map(|idx| idx.0)
+                else {
+                    return;
+                };
+                let Ok(mut filter_signal_data) = world
                     .query_filtered::<&mut FilterSignalData<T>, Allow<Internal>>()
                     .get_mut(world, parent)
-                    .unwrap();
+                else {
+                    return;
+                };
                 let old_filtered_state = filter_signal_data.items[item_index].filtered;
                 if old_filtered_state == filter {
-                    // No change, do nothing.
                     return;
                 }
                 let diff_to_queue = if filter {
@@ -1680,7 +1697,7 @@ pub trait SignalVecExt: SignalVec {
                 filter_signal_data.diffs.push(diff_to_queue);
 
                 // Poke the main output signal to process its queue immediately.
-                process_signals(world, [parent.into()], Box::new(Vec::<VecDiff<T>>::new()));
+                trigger_signal_subgraph(world, [parent.into()], Box::new(Vec::<VecDiff<T>>::new()));
             });
 
             // Use .map() to attach the processor. The dedupe is still important.
@@ -2042,7 +2059,7 @@ pub trait SignalVecExt: SignalVec {
     fn enumerate(self) -> Enumerate<Self>
     where
         Self: Sized,
-        Self::Item: Clone + 'static,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         #[derive(Component, Default)]
         struct EnumerateState {
@@ -2070,7 +2087,7 @@ pub trait SignalVecExt: SignalVec {
                         }
                     }
 
-                    let create_index_signal = clone!((processor_entity_handle) move | key: usize | {
+                    let create_index_signal = clone!((processor_entity_handle) move | key: usize | -> BoxedSignal<Option<usize>> {
                         signal::from_system(
                             clone!((processor_entity_handle) move |_: In<()>, query: Query<&EnumerateState, Allow<Internal>>| {
                                 Some(
@@ -2080,14 +2097,14 @@ pub trait SignalVecExt: SignalVec {
                                         .and_then(|s| s.key_to_index.get(&key).copied()),
                                 )
                             }),
-                        )
+                        ).boxed_clone()
                     });
                     for diff in diffs {
                         match diff {
                             VecDiff::Replace { values } => {
                                 state.key_to_index.clear();
                                 state.ordered_keys.clear();
-                                let new_values_with_signals = values.into_iter().enumerate().map(|(i, value)| {
+                                let new_values_with_signals: Vec<_> = values.into_iter().enumerate().map(|(i, value)| {
                                     let key = new_key_helper(&mut state);
                                     state.ordered_keys.push(key);
                                     state.key_to_index.insert(key, i);
@@ -2190,7 +2207,7 @@ pub trait SignalVecExt: SignalVec {
                 }
             );
             let handle = self
-                .for_each::<Vec<VecDiff<(super::signal::Source<Option<usize>>, Self::Item)>>, _, _, _>(processor_logic)
+                .for_each::<Vec<VecDiff<(BoxedSignal<Option<usize>>, Self::Item)>>, _, _, _>(processor_logic)
                 .register(world);
             processor_entity_handle.set(**handle);
             world.entity_mut(**handle).insert(EnumerateState::default());
@@ -2222,7 +2239,7 @@ pub trait SignalVecExt: SignalVec {
     fn to_signal(self) -> ToSignal<Self>
     where
         Self: Sized,
-        Self::Item: Clone + Send + 'static,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         let signal = self.for_each(|In(diffs), mut values: Local<Vec<Self::Item>>| {
             for diff in diffs {
@@ -2279,7 +2296,7 @@ pub trait SignalVecExt: SignalVec {
     fn is_empty(self) -> IsEmpty<Self>
     where
         Self: Sized,
-        Self::Item: Clone + Send + 'static,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         IsEmpty {
             signal: self.to_signal().map(|In(v): In<Vec<Self::Item>>| v.is_empty()),
@@ -2304,7 +2321,7 @@ pub trait SignalVecExt: SignalVec {
     fn len(self) -> Len<Self>
     where
         Self: Sized,
-        Self::Item: Clone + Send + 'static,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         Len {
             signal: self.to_signal().map(|In(v): In<Vec<Self::Item>>| v.len()),
@@ -2329,7 +2346,7 @@ pub trait SignalVecExt: SignalVec {
     fn sum(self) -> Sum<Self>
     where
         Self: Sized,
-        Self::Item: for<'a> core::iter::Sum<&'a Self::Item> + Clone + Send + 'static,
+        Self::Item: for<'a> core::iter::Sum<&'a Self::Item> + Clone + Send + Sync + 'static,
     {
         Sum {
             signal: self
@@ -2364,13 +2381,23 @@ pub trait SignalVecExt: SignalVec {
     where
         S: SignalVec<Item = Self::Item>,
         Self: Sized,
-        Self::Item: SSs + Clone,
+        Self::Item: Send + Sync + 'static + Clone,
     {
         let left_wrapper = self.for_each(|In(diffs)| LrDiff::Left(diffs));
         let right_wrapper = other.for_each(|In(diffs)| LrDiff::Right(diffs));
         let signal = lazy_signal_from_system::<_, Vec<VecDiff<Self::Item>>, _, _, _>(
-            move |In(lr_diff): In<LrDiff<Self::Item>>, mut left_len: Local<usize>, mut right_len: Local<usize>| {
-                let mut out_diffs = Vec::new();
+            move |In(lr_diff): In<LrDiff<Self::Item>>,
+                  mut left_len: Local<usize>,
+                  mut right_len: Local<usize>,
+                  mut accumulated: Local<Vec<VecDiff<Self::Item>>>,
+                  mut last_frame: Local<u32>,
+                  frame: Res<bevy_diagnostic::FrameCount>| {
+                // Clear accumulator at start of new frame
+                if *last_frame != frame.0 {
+                    accumulated.clear();
+                    *last_frame = frame.0;
+                }
+
                 let (is_left, diffs) = match lr_diff {
                     LrDiff::Left(diffs) => (true, diffs),
                     LrDiff::Right(diffs) => (false, diffs),
@@ -2382,55 +2409,55 @@ pub trait SignalVecExt: SignalVec {
                                 let removing = *left_len;
                                 *left_len = values.len();
                                 if *right_len == 0 {
-                                    out_diffs.push(VecDiff::Replace { values });
+                                    accumulated.push(VecDiff::Replace { values });
                                 } else {
                                     for i in (0..removing).rev() {
-                                        out_diffs.push(VecDiff::RemoveAt { index: i });
+                                        accumulated.push(VecDiff::RemoveAt { index: i });
                                     }
                                     for (i, value) in values.into_iter().enumerate() {
-                                        out_diffs.push(VecDiff::InsertAt { index: i, value });
+                                        accumulated.push(VecDiff::InsertAt { index: i, value });
                                     }
                                 }
                             }
                             VecDiff::InsertAt { index, value } => {
                                 *left_len += 1;
-                                out_diffs.push(VecDiff::InsertAt { index, value });
+                                accumulated.push(VecDiff::InsertAt { index, value });
                             }
                             VecDiff::UpdateAt { index, value } => {
-                                out_diffs.push(VecDiff::UpdateAt { index, value });
+                                accumulated.push(VecDiff::UpdateAt { index, value });
                             }
                             VecDiff::Move { old_index, new_index } => {
-                                out_diffs.push(VecDiff::Move { old_index, new_index });
+                                accumulated.push(VecDiff::Move { old_index, new_index });
                             }
                             VecDiff::RemoveAt { index } => {
                                 *left_len -= 1;
-                                out_diffs.push(VecDiff::RemoveAt { index });
+                                accumulated.push(VecDiff::RemoveAt { index });
                             }
                             VecDiff::Push { value } => {
                                 let index = *left_len;
                                 *left_len += 1;
                                 if *right_len == 0 {
-                                    out_diffs.push(VecDiff::Push { value });
+                                    accumulated.push(VecDiff::Push { value });
                                 } else {
-                                    out_diffs.push(VecDiff::InsertAt { index, value });
+                                    accumulated.push(VecDiff::InsertAt { index, value });
                                 }
                             }
                             VecDiff::Pop => {
                                 *left_len -= 1;
                                 if *right_len == 0 {
-                                    out_diffs.push(VecDiff::Pop);
+                                    accumulated.push(VecDiff::Pop);
                                 } else {
-                                    out_diffs.push(VecDiff::RemoveAt { index: *left_len });
+                                    accumulated.push(VecDiff::RemoveAt { index: *left_len });
                                 }
                             }
                             VecDiff::Clear => {
                                 let removing = *left_len;
                                 *left_len = 0;
                                 if *right_len == 0 {
-                                    out_diffs.push(VecDiff::Clear);
+                                    accumulated.push(VecDiff::Clear);
                                 } else {
                                     for i in (0..removing).rev() {
-                                        out_diffs.push(VecDiff::RemoveAt { index: i });
+                                        accumulated.push(VecDiff::RemoveAt { index: i });
                                     }
                                 }
                             }
@@ -2442,66 +2469,71 @@ pub trait SignalVecExt: SignalVec {
                                 let removing = *right_len;
                                 *right_len = values.len();
                                 if *left_len == 0 {
-                                    out_diffs.push(VecDiff::Replace { values });
+                                    accumulated.push(VecDiff::Replace { values });
                                 } else {
                                     for _ in 0..removing {
-                                        out_diffs.push(VecDiff::Pop);
+                                        accumulated.push(VecDiff::Pop);
                                     }
                                     for value in values {
-                                        out_diffs.push(VecDiff::Push { value });
+                                        accumulated.push(VecDiff::Push { value });
                                     }
                                 }
                             }
                             VecDiff::InsertAt { index, value } => {
                                 *right_len += 1;
-                                out_diffs.push(VecDiff::InsertAt {
+                                accumulated.push(VecDiff::InsertAt {
                                     index: index + *left_len,
                                     value,
                                 });
                             }
                             VecDiff::UpdateAt { index, value } => {
-                                out_diffs.push(VecDiff::UpdateAt {
+                                accumulated.push(VecDiff::UpdateAt {
                                     index: index + *left_len,
                                     value,
                                 });
                             }
                             VecDiff::Move { old_index, new_index } => {
-                                out_diffs.push(VecDiff::Move {
+                                accumulated.push(VecDiff::Move {
                                     old_index: old_index + *left_len,
                                     new_index: new_index + *left_len,
                                 });
                             }
                             VecDiff::RemoveAt { index } => {
                                 *right_len -= 1;
-                                out_diffs.push(VecDiff::RemoveAt {
+                                accumulated.push(VecDiff::RemoveAt {
                                     index: index + *left_len,
                                 });
                             }
                             VecDiff::Push { value } => {
                                 *right_len += 1;
-                                out_diffs.push(VecDiff::Push { value });
+                                accumulated.push(VecDiff::Push { value });
                             }
                             VecDiff::Pop => {
                                 *right_len -= 1;
-                                out_diffs.push(VecDiff::Pop);
+                                accumulated.push(VecDiff::Pop);
                             }
                             VecDiff::Clear => {
                                 let removing = *right_len;
                                 *right_len = 0;
                                 if *left_len == 0 {
-                                    out_diffs.push(VecDiff::Clear);
+                                    accumulated.push(VecDiff::Clear);
                                 } else {
                                     for _ in 0..removing {
-                                        out_diffs.push(VecDiff::Pop);
+                                        accumulated.push(VecDiff::Pop);
                                     }
                                 }
                             }
                         }
                     }
                 }
-                if out_diffs.is_empty() { None } else { Some(out_diffs) }
+                if accumulated.is_empty() {
+                    None
+                } else {
+                    Some(accumulated.clone())
+                }
             },
         );
+
         Chain {
             left_wrapper,
             right_wrapper,
@@ -2527,7 +2559,7 @@ pub trait SignalVecExt: SignalVec {
     fn intersperse(self, separator: Self::Item) -> Intersperse<Self>
     where
         Self: Sized,
-        Self::Item: Clone + SSs,
+        Self::Item: Clone + Send + Sync + 'static,
     {
         let signal = self.for_each(
             move |In(diffs): In<Vec<VecDiff<Self::Item>>>, mut local_values: Local<Vec<Self::Item>>| {
@@ -2656,16 +2688,16 @@ pub trait SignalVecExt: SignalVec {
     /// ```
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
-    /// use jonmo::signal::{Dedupe, Source};
+    /// use jonmo::signal::BoxedSignal;
     ///
     /// let mut world = World::new();
-    /// MutableVec::builder().values([1, 2, 3]).spawn(&mut world).signal_vec().intersperse_with(|_: In<Source<Option<usize>>>| 0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
+    /// MutableVec::builder().values([1, 2, 3]).spawn(&mut world).signal_vec().intersperse_with(|_: In<BoxedSignal<Option<usize>>>| 0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
     /// ```
     fn intersperse_with<F, M>(self, separator_system: F) -> IntersperseWith<Self>
     where
         Self: Sized,
-        Self::Item: Clone + SSs,
-        F: IntoSystem<In<super::signal::Source<Option<usize>>>, Self::Item, M> + SSs,
+        Self::Item: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<BoxedSignal<Option<usize>>>, Self::Item, M> + Send + Sync + 'static,
     {
         #[derive(Component)]
         struct IntersperseState<T> {
@@ -2713,7 +2745,7 @@ pub trait SignalVecExt: SignalVec {
                             )
                         }
                     ),
-                )
+                ).boxed_clone()
             });
 
             // 4. Define the main processor logic that handles incoming diffs.
@@ -2989,8 +3021,8 @@ pub trait SignalVecExt: SignalVec {
     fn sort_by<F, M>(self, compare_system: F) -> SortBy<Self>
     where
         Self: Sized,
-        Self::Item: Clone + SSs,
-        F: IntoSystem<In<(Self::Item, Self::Item)>, Ordering, M> + SSs,
+        Self::Item: Clone + Send + Sync + 'static,
+        F: IntoSystem<In<(Self::Item, Self::Item)>, Ordering, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let compare_system_id = world.register_system(compare_system);
@@ -3009,7 +3041,7 @@ pub trait SignalVecExt: SignalVec {
                 }
             }
 
-            fn search<T: Clone + SSs>(
+            fn search<T: Clone + Send + Sync + 'static>(
                 world: &mut World,
                 system_id: SystemId<In<(T, T)>, Ordering>,
                 state: &SortState<T>,
@@ -3176,7 +3208,7 @@ pub trait SignalVecExt: SignalVec {
     fn sort_by_cmp(self) -> SortBy<Self>
     where
         Self: Sized,
-        Self::Item: Ord + Clone + SSs,
+        Self::Item: Ord + Clone + Send + Sync + 'static,
     {
         self.sort_by(|In((left, right)): In<(Self::Item, Self::Item)>| left.cmp(&right))
     }
@@ -3201,9 +3233,9 @@ pub trait SignalVecExt: SignalVec {
     fn sort_by_key<K, F, M>(self, system: F) -> SortByKey<Self>
     where
         Self: Sized,
-        Self::Item: Clone + SSs,
-        K: Ord + Clone + SSs,
-        F: IntoSystem<In<Self::Item>, K, M> + SSs,
+        Self::Item: Clone + Send + Sync + 'static,
+        K: Ord + Clone + Send + Sync + 'static,
+        F: IntoSystem<In<Self::Item>, K, M> + Send + Sync + 'static,
     {
         let signal = LazySignal::new(move |world: &mut World| {
             let key_system_id = world.register_system(system);
@@ -3399,7 +3431,7 @@ pub trait SignalVecExt: SignalVec {
     where
         Self: Sized,
         Self::Item: SignalVec + 'static + Clone,
-        <Self::Item as SignalVec>::Item: Clone + SSs,
+        <Self::Item as SignalVec>::Item: Clone + Send + Sync + 'static,
     {
         type InnerItem<U> = <<U as SignalVec>::Item as SignalVec>::Item;
 
@@ -3460,7 +3492,7 @@ pub trait SignalVecExt: SignalVec {
             /// flattened output. Returns (processor handle, replay triggers to call
             /// later). NOTE: The caller should add the entry to FlattenState.items and
             /// THEN call trigger_replays.
-            fn create_inner_processor<O: Clone + SSs>(
+            fn create_inner_processor<O: Clone + Send + Sync + 'static>(
                 world: &mut World,
                 output_signal: SignalSystem,
                 index: usize,
@@ -3563,7 +3595,7 @@ pub trait SignalVecExt: SignalVec {
                             .unwrap()
                             .0
                             .extend(out_diffs);
-                        process_signals(world, [output_signal], Box::new(()));
+                        trigger_signal_subgraph(world, [output_signal], Box::new(()));
                     }
                 });
 
@@ -3824,7 +3856,7 @@ pub trait SignalVecExt: SignalVec {
                         .unwrap()
                         .0
                         .extend(out_diffs);
-                    process_signals(world, [output_signal], Box::new(()));
+                    trigger_signal_subgraph(world, [output_signal], Box::new(()));
                 }
             });
 
@@ -3870,7 +3902,7 @@ pub trait SignalVecExt: SignalVec {
     fn debug(self) -> Debug<Self>
     where
         Self: Sized,
-        Self::Item: fmt::Debug + Clone + 'static,
+        Self::Item: fmt::Debug + Clone + Send + Sync + 'static,
     {
         let location = core::panic::Location::caller();
         Debug {
@@ -3952,6 +3984,22 @@ pub trait SignalVecExt: SignalVec {
         Box::new(self)
     }
 
+    /// Assign a schedule to this signal vec chain, see [`SignalExt::schedule`].
+    fn schedule<Sched: ScheduleLabel + Default + 'static>(self) -> ScheduledVec<Sched, Self::Item>
+    where
+        Self: Sized + 'static,
+    {
+        let signal = LazySignal::new(move |world: &mut World| {
+            let handle = self.register_signal_vec(world);
+            apply_schedule_to_signal(world, *handle, Sched::default().intern());
+            *handle
+        });
+        ScheduledVec {
+            signal,
+            _marker: PhantomData,
+        }
+    }
+
     /// Activate this [`SignalVec`] and all its upstreams, causing them to be evaluated every frame
     /// until they are [`SignalHandle::cleanup`]-ed, see [`SignalHandle`].
     fn register(self, world: &mut World) -> SignalHandle
@@ -3964,6 +4012,30 @@ pub trait SignalVecExt: SignalVec {
 
 impl<T: ?Sized> SignalVecExt for T where T: SignalVec {}
 
+/// Signal vec node wrapper that assigns a schedule to a signal chain, see
+/// [`.schedule`](SignalVecExt::schedule).
+pub struct ScheduledVec<Sched, I> {
+    signal: LazySignal,
+    _marker: PhantomData<fn() -> (Sched, I)>,
+}
+
+impl<Sched, I> Clone for ScheduledVec<Sched, I> {
+    fn clone(&self) -> Self {
+        Self {
+            signal: self.signal.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<Sched: 'static, I: Send + Sync + 'static> SignalVec for ScheduledVec<Sched, I> {
+    type Item = I;
+
+    fn register_boxed_signal_vec(self: Box<Self>, world: &mut World) -> SignalHandle {
+        self.signal.register(world).into()
+    }
+}
+
 /// Provides immutable access to the underlying [`Vec`].
 pub struct MutableVecReadGuard<'s, T> {
     guard: &'s MutableVecData<T>,
@@ -4131,7 +4203,7 @@ impl<T> Drop for MutableVec<T> {
 }
 
 impl<T> MutableVec<T> {
-    /// Creates a [`Builder`] for constructing a [`MutableVec`].
+    /// Creates a [`MutableVecBuilder`] for constructing a [`MutableVec`].
     ///
     /// # Example
     ///
@@ -4149,15 +4221,15 @@ impl<T> MutableVec<T> {
     ///     .with_values(|v| v.extend(0..10))
     ///     .spawn(&mut world);
     /// ```
-    pub fn builder() -> Builder<T> {
-        Builder::new()
+    pub fn builder() -> MutableVecBuilder<T> {
+        MutableVecBuilder::new()
     }
 
     /// Provides read-only access to the underlying [`Vec`] via either a `&World` or a
     /// `&Query<MutableVecData<T>>`.
     pub fn read<'s>(&self, mutable_vec_data_reader: impl ReadMutableVecData<'s, T>) -> MutableVecReadGuard<'s, T>
     where
-        T: SSs,
+        T: Send + Sync + 'static,
     {
         MutableVecReadGuard {
             guard: mutable_vec_data_reader.read(self.entity),
@@ -4167,7 +4239,7 @@ impl<T> MutableVec<T> {
     /// `&mut Query<&mut MutableVecData<T>>`.
     pub fn write<'w>(&self, mutable_vec_data_writer: impl WriteMutableVecData<'w, T>) -> MutableVecWriteGuard<'w, T>
     where
-        T: SSs,
+        T: Send + Sync + 'static,
     {
         MutableVecWriteGuard {
             guard: mutable_vec_data_writer.write(self.entity),
@@ -4177,7 +4249,7 @@ impl<T> MutableVec<T> {
     /// Returns a [`Source`] signal from this [`MutableVec`].
     pub fn signal_vec(&self) -> Source<T>
     where
-        T: Clone + SSs,
+        T: Clone + Send + Sync + 'static,
     {
         let replay_lazy_signal = LazySignal::new(clone!((self => self_) move |world: &mut World| {
             let broadcaster_system = world.get::<MutableVecData<T>>(self_.entity).unwrap().broadcaster.clone().register(world);
@@ -4209,7 +4281,7 @@ impl<T> MutableVec<T> {
             replay_entity.set(*replay_signal);
 
             let trigger = Box::new(move |world: &mut World| {
-                process_signals(world, [replay_signal], Box::new(Vec::<VecDiff<T>>::new()));
+                trigger_signal_subgraph(world, [replay_signal], Box::new(Vec::<VecDiff<T>>::new()));
             });
 
             world.entity_mut(*replay_signal).insert((VecReplayTrigger(trigger), ReplayOnce));
@@ -4234,7 +4306,7 @@ pub(crate) fn despawn_stale_mutable_vecs(world: &mut World) {
 
 fn new_mutable_vec_data<T>(values: Vec<T>) -> (MutableVecData<T>, LazyEntity)
 where
-    T: Clone + SSs,
+    T: Clone + Send + Sync + 'static,
 {
     let data_entity = LazyEntity::new();
     let broadcaster = LazySignal::new(clone!((data_entity) move |world: &mut World| {
@@ -4261,7 +4333,7 @@ where
 
 impl<T> From<&mut World> for MutableVec<T>
 where
-    T: Clone + SSs,
+    T: Clone + Send + Sync + 'static,
 {
     fn from(world: &mut World) -> Self {
         let (data, data_entity) = new_mutable_vec_data::<T>(Vec::new());
@@ -4277,7 +4349,7 @@ where
 
 impl<T> FromWorld for MutableVec<T>
 where
-    T: Clone + SSs,
+    T: Clone + Send + Sync + 'static,
 {
     fn from_world(world: &mut World) -> Self {
         world.into()
@@ -4295,15 +4367,15 @@ where
 /// let mut world = World::new();
 /// let vec = MutableVec::builder().values([1, 2, 3]).spawn(&mut world);
 /// ```
-pub struct Builder<T>(Vec<T>);
+pub struct MutableVecBuilder<T>(Vec<T>);
 
-impl<T> Default for Builder<T> {
+impl<T> Default for MutableVecBuilder<T> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<T> Builder<T> {
+impl<T> MutableVecBuilder<T> {
     /// Creates a new empty builder.
     pub fn new() -> Self {
         Self(Vec::new())
@@ -4347,7 +4419,7 @@ impl<T> Builder<T> {
     }
 }
 
-impl<T, A> From<A> for Builder<T>
+impl<T, A> From<A> for MutableVecBuilder<T>
 where
     Vec<T>: From<A>,
 {
@@ -4356,7 +4428,7 @@ where
     }
 }
 
-impl<T: SSs + Clone> Builder<T> {
+impl<T: Send + Sync + 'static + Clone> MutableVecBuilder<T> {
     /// Spawns a [`MutableVec`] using a `&mut World`.
     pub fn spawn(self, world: &mut World) -> MutableVec<T> {
         let (data, data_entity) = new_mutable_vec_data::<T>(self.0);
@@ -4384,7 +4456,7 @@ impl<T: SSs + Clone> Builder<T> {
 
 impl<T> From<&mut Commands<'_, '_>> for MutableVec<T>
 where
-    T: Clone + SSs,
+    T: Clone + Send + Sync + 'static,
 {
     fn from(commands: &mut Commands) -> Self {
         let (data, data_entity) = new_mutable_vec_data::<T>(Vec::new());
@@ -4460,7 +4532,7 @@ where
 
 impl<'s, T> ReadMutableVecData<'s, T> for &'s Query<'_, 's, &MutableVecData<T>>
 where
-    T: SSs,
+    T: Send + Sync + 'static,
 {
     fn read(self, entity: Entity) -> &'s MutableVecData<T> {
         self.get(entity).unwrap()
@@ -4469,7 +4541,7 @@ where
 
 impl<'s, T> ReadMutableVecData<'s, T> for &'s World
 where
-    T: SSs,
+    T: Send + Sync + 'static,
 {
     fn read(self, entity: Entity) -> &'s MutableVecData<T> {
         self.get(entity).unwrap()
@@ -4487,7 +4559,7 @@ where
 
 impl<'a, 'w, 's, T> WriteMutableVecData<'a, T> for &'a mut Query<'w, 's, &mut MutableVecData<T>>
 where
-    T: SSs,
+    T: Send + Sync + 'static,
 {
     fn write(self, entity: Entity) -> Mut<'a, MutableVecData<T>> {
         self.get_mut(entity).unwrap()
@@ -4496,7 +4568,7 @@ where
 
 impl<'w, T> WriteMutableVecData<'w, T> for &'w mut World
 where
-    T: SSs,
+    T: Send + Sync + 'static,
 {
     fn write(self, entity: Entity) -> Mut<'w, MutableVecData<T>> {
         self.get_mut(entity).unwrap()
@@ -4524,7 +4596,7 @@ pub(crate) mod tests {
     // Helper system to capture signal_vec output
     fn capture_signal_vec_output<T>(In(diffs): In<Vec<VecDiff<T>>>, mut output: ResMut<SignalVecOutput<T>>)
     where
-        T: SSs + Clone + fmt::Debug,
+        T: Send + Sync + 'static + Clone + fmt::Debug,
     {
         #[cfg(feature = "tracing")]
         bevy_log::debug!(
@@ -4536,14 +4608,14 @@ pub(crate) mod tests {
     }
 
     // Helper to make assertions cleaner
-    fn get_and_clear_output<T: SSs + Clone + fmt::Debug>(world: &mut World) -> Vec<VecDiff<T>> {
+    fn get_and_clear_output<T: Send + Sync + 'static + Clone + fmt::Debug>(world: &mut World) -> Vec<VecDiff<T>> {
         let output = world.resource::<SignalVecOutput<T>>().0.clone();
         world.resource_mut::<SignalVecOutput<T>>().0.clear();
         output
     }
 
     // Add this PartialEq implementation for easier testing
-    impl<T: SSs + PartialEq + fmt::Debug> PartialEq for VecDiff<T> {
+    impl<T: Send + Sync + 'static + PartialEq + fmt::Debug> PartialEq for VecDiff<T> {
         fn eq(&self, other: &Self) -> bool {
             match (self, other) {
                 (Self::Replace { values: l_values }, Self::Replace { values: r_values }) => l_values == r_values,
@@ -4594,16 +4666,16 @@ pub(crate) mod tests {
     }
 
     #[derive(Resource, Default, Debug)]
-    struct FinalSignalOutput<T: SSs + Clone + fmt::Debug>(Option<T>);
+    struct FinalSignalOutput<T: Send + Sync + 'static + Clone + fmt::Debug>(Option<T>);
 
     fn capture_final_output<T>(In(value): In<T>, mut output: ResMut<FinalSignalOutput<T>>)
     where
-        T: SSs + Clone + fmt::Debug,
+        T: Send + Sync + 'static + Clone + fmt::Debug,
     {
         output.0 = Some(value);
     }
 
-    fn get_and_clear_final_output<T: SSs + Clone + fmt::Debug>(world: &mut World) -> Option<T> {
+    fn get_and_clear_final_output<T: Send + Sync + 'static + Clone + fmt::Debug>(world: &mut World) -> Option<T> {
         world
             .get_resource_mut::<FinalSignalOutput<T>>()
             .and_then(|mut res| res.0.take())
@@ -7043,7 +7115,7 @@ pub(crate) mod tests {
     enum ItemOrSep {
         Item(u32),
         // The separator variant holds the *unregistered* index signal.
-        Sep(crate::signal::Source<Option<usize>>),
+        Sep(crate::signal::BoxedSignal<Option<usize>>),
     }
 
     impl Clone for ItemOrSep {
@@ -7110,11 +7182,7 @@ pub(crate) mod tests {
 
             let source_vec = MutableVec::builder().values([10u32, 20, 30]).spawn(app.world_mut());
 
-            // CORRECTION: The closure's input parameter must be the concrete type
-            // `signal::Source<Option<usize>>`, not a generic `impl Signal`. This satisfies
-            // the `IntoSystem` trait bound.
-            let separator_factory =
-                |In(index_signal): In<crate::signal::Source<Option<usize>>>| ItemOrSep::Sep(index_signal);
+            let separator_factory = |In(index_signal): In<BoxedSignal<Option<usize>>>| ItemOrSep::Sep(index_signal);
 
             let interspersed_signal = source_vec
                 .signal_vec()
@@ -7132,9 +7200,7 @@ pub(crate) mod tests {
             app.update();
             apply_diffs(&mut current_state, get_and_clear_output::<ItemOrSep>(app.world_mut()));
 
-            // CORRECTION: Use the correct `signal::Source` for the placeholder.
-            // We also need to provide the type hint for the closure to resolve ambiguity.
-            let placeholder_sep = ItemOrSep::Sep(signal::from_system(|_: In<()>| None::<usize>));
+            let placeholder_sep = ItemOrSep::Sep(signal::from_system(|_: In<()>| None::<usize>).boxed_clone());
             assert_eq!(
                 current_state,
                 vec![
@@ -7600,8 +7666,7 @@ pub(crate) mod tests {
             // --- 1. Setup ---
             let mut app = create_test_app();
 
-            use crate::signal::Source;
-            type EnumeratedItem = (Source<Option<usize>>, i32);
+            type EnumeratedItem = (BoxedSignal<Option<usize>>, i32);
 
             #[derive(Resource, Default)]
             struct EnumOutput(Vec<VecDiff<EnumeratedItem>>);
@@ -7627,11 +7692,11 @@ pub(crate) mod tests {
             };
 
             // Track all items with their index signals throughout the test
-            let mut tracked_items: Vec<(Source<Option<usize>>, i32)>;
+            let mut tracked_items: Vec<(BoxedSignal<Option<usize>>, i32)>;
 
             // Helper to verify index signals match their positions
             let verify_indices =
-                |world: &mut World, items: &[(Source<Option<usize>>, i32)], expected: &[(usize, i32)]| {
+                |world: &mut World, items: &[(BoxedSignal<Option<usize>>, i32)], expected: &[(usize, i32)]| {
                     assert_eq!(items.len(), expected.len(), "Item count mismatch");
                     for (i, ((index_signal, value), (expected_index, expected_value))) in
                         items.iter().zip(expected.iter()).enumerate()
diff --git a/src/utils.rs b/src/utils.rs
index 7d53b39..a60fcab 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -72,7 +72,3 @@ where
 {
     x.deref().clone()
 }
-
-/// Convenience trait for [`Send`] + [`Sync`] + 'static.
-pub trait SSs: Send + Sync + 'static {}
-impl<T: Send + Sync + 'static> SSs for T {}