From 5b44379af25b2740af2f979d26f57ed9d5dbf99a Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Mon, 25 Aug 2025 09:55:19 -0500
Subject: [PATCH 1/4] Add some traits read only signal works with sync storage

---
 packages/core-macro/src/props/mod.rs    |   1 +
 packages/signals/examples/send.rs       |  14 +-
 packages/signals/examples/send_store.rs |  27 +++
 packages/signals/src/boxed.rs           | 257 ++++++++++++++++++------
 packages/signals/src/write.rs           |   2 +-
 packages/stores/src/store.rs            |  74 +++++--
 6 files changed, 292 insertions(+), 83 deletions(-)
 create mode 100644 packages/signals/examples/send_store.rs

diff --git a/packages/core-macro/src/props/mod.rs b/packages/core-macro/src/props/mod.rs
index d994b9057f..47356ecd7e 100644
--- a/packages/core-macro/src/props/mod.rs
+++ b/packages/core-macro/src/props/mod.rs
@@ -1766,6 +1766,7 @@ fn looks_like_write_type(ty: &Type) -> bool {
 fn looks_like_store_type(ty: &Type) -> bool {
     last_segment_matches(ty, &parse_quote!(Store))
         || last_segment_matches(ty, &parse_quote!(ReadStore))
+        || last_segment_matches(ty, &parse_quote!(WriteStore))
 }
 
 fn looks_like_callback_type(ty: &Type) -> bool {
diff --git a/packages/signals/examples/send.rs b/packages/signals/examples/send.rs
index 3591d9f058..b55d2952f9 100644
--- a/packages/signals/examples/send.rs
+++ b/packages/signals/examples/send.rs
@@ -7,6 +7,15 @@ fn main() {
 fn app() -> Element {
     let mut signal = use_signal_sync(|| 0);
 
+    rsx! {
+        button { onclick: move |_| signal += 1, "Increase" }
+        "{signal}"
+        Child { signal }
+    }
+}
+
+#[component]
+fn Child(signal: WriteSignal<u32, SyncStorage>) -> Element {
     use_hook(|| {
         std::thread::spawn(move || loop {
             std::thread::sleep(std::time::Duration::from_secs(1));
@@ -14,8 +23,5 @@ fn app() -> Element {
         });
     });
 
-    rsx! {
-        button { onclick: move |_| signal += 1, "Increase" }
-        "{signal}"
-    }
+    rsx! {}
 }
diff --git a/packages/signals/examples/send_store.rs b/packages/signals/examples/send_store.rs
new file mode 100644
index 0000000000..60768c6c21
--- /dev/null
+++ b/packages/signals/examples/send_store.rs
@@ -0,0 +1,27 @@
+use dioxus::prelude::*;
+
+fn main() {
+    dioxus::launch(app);
+}
+
+fn app() -> Element {
+    let mut store = use_hook(|| Store::new_maybe_sync(0u32));
+
+    rsx! {
+        button { onclick: move |_| store += 1, "Increase" }
+        "{store}"
+        Child { store }
+    }
+}
+
+#[component]
+fn Child(store: WriteStore<u32, SyncStorage>) -> Element {
+    use_hook(|| {
+        std::thread::spawn(move || loop {
+            std::thread::sleep(std::time::Duration::from_secs(1));
+            store += 1;
+        });
+    });
+
+    rsx! {}
+}
diff --git a/packages/signals/src/boxed.rs b/packages/signals/src/boxed.rs
index 6f97679539..b1d3c9ac3a 100644
--- a/packages/signals/src/boxed.rs
+++ b/packages/signals/src/boxed.rs
@@ -1,11 +1,12 @@
 use std::{any::Any, ops::Deref};
 
 use dioxus_core::{IntoAttributeValue, IntoDynNode, Subscribers};
-use generational_box::{BorrowResult, UnsyncStorage};
+use generational_box::{BorrowResult, Storage, SyncStorage, UnsyncStorage};
 
 use crate::{
     read_impls, write_impls, CopyValue, Global, InitializeFromFunction, MappedMutSignal,
-    MappedSignal, Memo, Readable, ReadableExt, ReadableRef, Signal, Writable, WritableExt,
+    MappedSignal, Memo, Readable, ReadableExt, ReadableRef, Signal, SignalData, Writable,
+    WritableExt,
 };
 
 /// A signal that can only be read from.
@@ -13,18 +14,116 @@ use crate::{
     since = "0.7.0",
     note = "Use `ReadSignal` instead. Will be removed in 0.8"
 )]
-pub type ReadOnlySignal<T> = ReadSignal<T>;
+pub type ReadOnlySignal<T, S> = ReadSignal<T, S>;
+
+mod sealed {
+    use generational_box::{SyncStorage, UnsyncStorage};
+
+    pub trait Sealed {}
+    impl Sealed for UnsyncStorage {}
+    impl Sealed for SyncStorage {}
+
+    pub struct SealedToken;
+}
+
+/// A trait for creating boxed readable and writable signals. This is implemented for
+/// [UnsyncStorage] and [SyncStorage].
+pub trait ReadOnlySignalStorage<T: ?Sized>:
+    Storage<Box<Self::DynReadable>> + Storage<Box<Self::DynWritable>> + sealed::Sealed + 'static
+{
+    #[doc(hidden)]
+    type DynReadable: Readable<Target = T, Storage = Self> + ?Sized;
+    #[doc(hidden)]
+    type DynWritable: Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>> + ?Sized;
+}
+
+/// A trait for creating boxed readable and writable signals. This is implemented for
+/// [UnsyncStorage] and [SyncStorage].
+///
+/// The storage type must implement `CreateReadOnlySignalStorage` for the specific readable type
+/// to be used with `ReadSignal` and `WriteSignal`.
+pub trait CreateReadOnlySignalStorage<T: Readable + ?Sized>:
+    ReadOnlySignalStorage<T::Target> + 'static
+{
+    #[doc(hidden)]
+    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable>
+    where
+        T: Sized;
+
+    #[doc(hidden)]
+    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable>
+    where
+        T: Writable + Sized;
+}
+
+impl<T: ?Sized + 'static> ReadOnlySignalStorage<T> for UnsyncStorage {
+    type DynReadable = dyn Readable<Target = T, Storage = Self>;
+    type DynWritable = dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>>;
+}
+
+impl<T: Readable<Storage = UnsyncStorage> + ?Sized + 'static> CreateReadOnlySignalStorage<T>
+    for UnsyncStorage
+{
+    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable>
+    where
+        T: Sized,
+    {
+        Box::new(value)
+    }
+
+    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable>
+    where
+        T: Writable + Sized,
+    {
+        Box::new(BoxWriteMetadata::new(value))
+    }
+}
+
+impl<T: ?Sized + 'static> ReadOnlySignalStorage<T> for SyncStorage {
+    type DynReadable = dyn Readable<Target = T, Storage = Self> + Send + Sync;
+    type DynWritable =
+        dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>> + Send + Sync;
+}
+
+impl<T: Readable<Storage = SyncStorage> + Sync + Send + ?Sized + 'static>
+    CreateReadOnlySignalStorage<T> for SyncStorage
+{
+    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable>
+    where
+        T: Sized,
+    {
+        Box::new(value)
+    }
+
+    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable>
+    where
+        T: Writable + Sized,
+    {
+        Box::new(BoxWriteMetadata::new(value))
+    }
+}
 
 /// A boxed version of [Readable] that can be used to store any readable type.
-pub struct ReadSignal<T: ?Sized> {
-    value: CopyValue<Box<dyn Readable<Target = T, Storage = UnsyncStorage>>>,
+pub struct ReadSignal<T: ?Sized, S: ReadOnlySignalStorage<T> = UnsyncStorage> {
+    value: CopyValue<Box<S::DynReadable>, S>,
 }
 
 impl<T: ?Sized + 'static> ReadSignal<T> {
     /// Create a new boxed readable value.
     pub fn new(value: impl Readable<Target = T, Storage = UnsyncStorage> + 'static) -> Self {
+        Self::new_maybe_sync(value)
+    }
+}
+
+impl<T: ?Sized + 'static, S: ReadOnlySignalStorage<T>> ReadSignal<T, S> {
+    /// Create a new boxed readable value which may be sync
+    pub fn new_maybe_sync<R>(value: R) -> Self
+    where
+        S: CreateReadOnlySignalStorage<R>,
+        R: Readable<Target = T>,
+    {
         Self {
-            value: CopyValue::new(Box::new(value)),
+            value: CopyValue::new_maybe_sync(S::new_readable(value, sealed::SealedToken)),
         }
     }
 
@@ -56,29 +155,35 @@ impl<T: ?Sized + 'static> ReadSignal<T> {
     }
 }
 
-impl<T: ?Sized> Clone for ReadSignal<T> {
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Clone for ReadSignal<T, S> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<T: ?Sized> Copy for ReadSignal<T> {}
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Copy for ReadSignal<T, S> {}
 
-impl<T: ?Sized> PartialEq for ReadSignal<T> {
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> PartialEq for ReadSignal<T, S> {
     fn eq(&self, other: &Self) -> bool {
         self.value == other.value
     }
 }
 
-impl<T: Default + 'static> Default for ReadSignal<T> {
+impl<
+        T: Default + 'static,
+        S: CreateReadOnlySignalStorage<Signal<T, S>>
+            + ReadOnlySignalStorage<T>
+            + Storage<SignalData<T>>,
+    > Default for ReadSignal<T, S>
+{
     fn default() -> Self {
-        Self::new(Signal::new(T::default()))
+        Self::new_maybe_sync(Signal::new_maybe_sync(T::default()))
     }
 }
 
-read_impls!(ReadSignal<T>);
+read_impls!(ReadSignal<T, S: ReadOnlySignalStorage<T>>);
 
-impl<T> IntoAttributeValue for ReadSignal<T>
+impl<T, S: ReadOnlySignalStorage<T>> IntoAttributeValue for ReadSignal<T, S>
 where
     T: Clone + IntoAttributeValue + 'static,
 {
@@ -87,16 +192,17 @@ where
     }
 }
 
-impl<T> IntoDynNode for ReadSignal<T>
+impl<T, S> IntoDynNode for ReadSignal<T, S>
 where
     T: Clone + IntoDynNode + 'static,
+    S: ReadOnlySignalStorage<T>,
 {
     fn into_dyn_node(self) -> dioxus_core::DynamicNode {
         self.with(|f| f.clone().into_dyn_node())
     }
 }
 
-impl<T: Clone + 'static> Deref for ReadSignal<T> {
+impl<T: Clone + 'static, S: ReadOnlySignalStorage<T>> Deref for ReadSignal<T, S> {
     type Target = dyn Fn() -> T;
 
     fn deref(&self) -> &Self::Target {
@@ -104,9 +210,9 @@ impl<T: Clone + 'static> Deref for ReadSignal<T> {
     }
 }
 
-impl<T: ?Sized> Readable for ReadSignal<T> {
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Readable for ReadSignal<T, S> {
     type Target = T;
-    type Storage = UnsyncStorage;
+    type Storage = S;
 
     #[track_caller]
     fn try_read_unchecked(
@@ -143,9 +249,15 @@ impl<T: ?Sized> Readable for ReadSignal<T> {
 // We can't implement From<impl Readable<Target = T, Storage = S> > for ReadSignal<T, S>
 // because it would conflict with the From<T> for T implementation, but we can implement it for
 // all specific readable types
-impl<T: 'static> From<Signal<T>> for ReadSignal<T> {
-    fn from(value: Signal<T>) -> Self {
-        Self::new(value)
+impl<
+        T: 'static,
+        S: CreateReadOnlySignalStorage<Signal<T, S>>
+            + ReadOnlySignalStorage<T>
+            + Storage<SignalData<T>>,
+    > From<Signal<T, S>> for ReadSignal<T, S>
+{
+    fn from(value: Signal<T, S>) -> Self {
+        Self::new_maybe_sync(value)
     }
 }
 impl<T: PartialEq + 'static> From<Memo<T>> for ReadSignal<T> {
@@ -153,9 +265,13 @@ impl<T: PartialEq + 'static> From<Memo<T>> for ReadSignal<T> {
         Self::new(value)
     }
 }
-impl<T: 'static> From<CopyValue<T>> for ReadSignal<T> {
-    fn from(value: CopyValue<T>) -> Self {
-        Self::new(value)
+impl<
+        T: 'static,
+        S: CreateReadOnlySignalStorage<CopyValue<T, S>> + ReadOnlySignalStorage<T> + Storage<T>,
+    > From<CopyValue<T, S>> for ReadSignal<T, S>
+{
+    fn from(value: CopyValue<T, S>) -> Self {
+        Self::new_maybe_sync(value)
     }
 }
 impl<T, R> From<Global<T, R>> for ReadSignal<R>
@@ -167,38 +283,41 @@ where
         Self::new(value)
     }
 }
-impl<V, O, F> From<MappedSignal<O, V, F>> for ReadSignal<O>
+impl<V, O, F, S> From<MappedSignal<O, V, F>> for ReadSignal<O, S>
 where
     O: ?Sized + 'static,
-    V: Readable<Storage = UnsyncStorage> + 'static,
+    V: Readable<Storage = S> + 'static,
     F: Fn(&V::Target) -> &O + 'static,
+    S: ReadOnlySignalStorage<O> + CreateReadOnlySignalStorage<MappedSignal<O, V, F>>,
 {
     fn from(value: MappedSignal<O, V, F>) -> Self {
-        Self::new(value)
+        Self::new_maybe_sync(value)
     }
 }
-impl<V, O, F, FMut> From<MappedMutSignal<O, V, F, FMut>> for ReadSignal<O>
+impl<V, O, F, FMut, S> From<MappedMutSignal<O, V, F, FMut>> for ReadSignal<O, S>
 where
     O: ?Sized + 'static,
-    V: Readable<Storage = UnsyncStorage> + 'static,
+    V: Readable<Storage = S> + 'static,
     F: Fn(&V::Target) -> &O + 'static,
     FMut: 'static,
+    S: ReadOnlySignalStorage<O> + CreateReadOnlySignalStorage<MappedMutSignal<O, V, F, FMut>>,
 {
     fn from(value: MappedMutSignal<O, V, F, FMut>) -> Self {
-        Self::new(value)
+        Self::new_maybe_sync(value)
     }
 }
-impl<T: ?Sized + 'static> From<WriteSignal<T>> for ReadSignal<T> {
-    fn from(value: WriteSignal<T>) -> Self {
-        Self::new(value)
+impl<T: ?Sized + 'static, S> From<WriteSignal<T, S>> for ReadSignal<T, S>
+where
+    S: ReadOnlySignalStorage<T> + CreateReadOnlySignalStorage<WriteSignal<T, S>>,
+{
+    fn from(value: WriteSignal<T, S>) -> Self {
+        Self::new_maybe_sync(value)
     }
 }
 
 /// A boxed version of [Writable] that can be used to store any writable type.
-pub struct WriteSignal<T: ?Sized> {
-    value: CopyValue<
-        Box<dyn Writable<Target = T, Storage = UnsyncStorage, WriteMetadata = Box<dyn Any>>>,
-    >,
+pub struct WriteSignal<T: ?Sized, S: ReadOnlySignalStorage<T> = UnsyncStorage> {
+    value: CopyValue<Box<S::DynWritable>, S>,
 }
 
 impl<T: ?Sized + 'static> WriteSignal<T> {
@@ -206,8 +325,19 @@ impl<T: ?Sized + 'static> WriteSignal<T> {
     pub fn new(
         value: impl Writable<Target = T, Storage = UnsyncStorage, WriteMetadata: 'static> + 'static,
     ) -> Self {
+        Self::new_maybe_sync(value)
+    }
+}
+
+impl<T: ?Sized + 'static, S: ReadOnlySignalStorage<T>> WriteSignal<T, S> {
+    /// Create a new boxed writable value which may be sync
+    pub fn new_maybe_sync<R>(value: R) -> Self
+    where
+        R: Writable<Target = T, WriteMetadata: 'static>,
+        S: CreateReadOnlySignalStorage<R>,
+    {
         Self {
-            value: CopyValue::new(Box::new(BoxWriteMetadata::new(value))),
+            value: CopyValue::new_maybe_sync(S::new_writable(value, sealed::SealedToken)),
         }
     }
 }
@@ -272,42 +402,44 @@ where
     }
 }
 
-impl<T: ?Sized> Clone for WriteSignal<T> {
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Clone for WriteSignal<T, S> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<T: ?Sized> Copy for WriteSignal<T> {}
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Copy for WriteSignal<T, S> {}
 
-impl<T: ?Sized> PartialEq for WriteSignal<T> {
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> PartialEq for WriteSignal<T, S> {
     fn eq(&self, other: &Self) -> bool {
         self.value == other.value
     }
 }
 
-read_impls!(WriteSignal<T>);
-write_impls!(WriteSignal<T>);
+read_impls!(WriteSignal<T, S: ReadOnlySignalStorage<T>>);
+write_impls!(WriteSignal<T, S: ReadOnlySignalStorage<T>>);
 
-impl<T> IntoAttributeValue for WriteSignal<T>
+impl<T, S> IntoAttributeValue for WriteSignal<T, S>
 where
     T: Clone + IntoAttributeValue + 'static,
+    S: ReadOnlySignalStorage<T>,
 {
     fn into_value(self) -> dioxus_core::AttributeValue {
         self.with(|f| f.clone().into_value())
     }
 }
 
-impl<T> IntoDynNode for WriteSignal<T>
+impl<T, S> IntoDynNode for WriteSignal<T, S>
 where
     T: Clone + IntoDynNode + 'static,
+    S: ReadOnlySignalStorage<T>,
 {
     fn into_dyn_node(self) -> dioxus_core::DynamicNode {
         self.with(|f| f.clone().into_dyn_node())
     }
 }
 
-impl<T: Clone + 'static> Deref for WriteSignal<T> {
+impl<T: Clone + 'static, S: ReadOnlySignalStorage<T>> Deref for WriteSignal<T, S> {
     type Target = dyn Fn() -> T;
 
     fn deref(&self) -> &Self::Target {
@@ -315,9 +447,9 @@ impl<T: Clone + 'static> Deref for WriteSignal<T> {
     }
 }
 
-impl<T: ?Sized> Readable for WriteSignal<T> {
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Readable for WriteSignal<T, S> {
     type Target = T;
-    type Storage = UnsyncStorage;
+    type Storage = S;
 
     #[track_caller]
     fn try_read_unchecked(
@@ -351,7 +483,7 @@ impl<T: ?Sized> Readable for WriteSignal<T> {
     }
 }
 
-impl<T: ?Sized> Writable for WriteSignal<T> {
+impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Writable for WriteSignal<T, S> {
     type WriteMetadata = Box<dyn Any>;
 
     fn try_write_unchecked(
@@ -370,14 +502,24 @@ impl<T: ?Sized> Writable for WriteSignal<T> {
 // We can't implement From<impl Writable<Target = T, Storage = S>> for Write<T, S>
 // because it would conflict with the From<T> for T implementation, but we can implement it for
 // all specific readable types
-impl<T: 'static> From<Signal<T>> for WriteSignal<T> {
-    fn from(value: Signal<T>) -> Self {
-        Self::new(value)
+impl<
+        T: 'static,
+        S: CreateReadOnlySignalStorage<Signal<T, S>>
+            + ReadOnlySignalStorage<T>
+            + Storage<SignalData<T>>,
+    > From<Signal<T, S>> for WriteSignal<T, S>
+{
+    fn from(value: Signal<T, S>) -> Self {
+        Self::new_maybe_sync(value)
     }
 }
-impl<T: 'static> From<CopyValue<T>> for WriteSignal<T> {
-    fn from(value: CopyValue<T>) -> Self {
-        Self::new(value)
+impl<
+        T: 'static,
+        S: CreateReadOnlySignalStorage<CopyValue<T, S>> + ReadOnlySignalStorage<T> + Storage<T>,
+    > From<CopyValue<T, S>> for WriteSignal<T, S>
+{
+    fn from(value: CopyValue<T, S>) -> Self {
+        Self::new_maybe_sync(value)
     }
 }
 impl<T, R> From<Global<T, R>> for WriteSignal<R>
@@ -389,14 +531,15 @@ where
         Self::new(value)
     }
 }
-impl<V, O, F, FMut> From<MappedMutSignal<O, V, F, FMut>> for WriteSignal<O>
+impl<V, O, F, FMut, S> From<MappedMutSignal<O, V, F, FMut>> for WriteSignal<O, S>
 where
     O: ?Sized + 'static,
-    V: Writable<Storage = UnsyncStorage> + 'static,
+    V: Writable<Storage = S> + 'static,
     F: Fn(&V::Target) -> &O + 'static,
     FMut: Fn(&mut V::Target) -> &mut O + 'static,
+    S: CreateReadOnlySignalStorage<MappedMutSignal<O, V, F, FMut>> + ReadOnlySignalStorage<O>,
 {
     fn from(value: MappedMutSignal<O, V, F, FMut>) -> Self {
-        Self::new(value)
+        Self::new_maybe_sync(value)
     }
 }
diff --git a/packages/signals/src/write.rs b/packages/signals/src/write.rs
index 461ca6ef95..098ee6561d 100644
--- a/packages/signals/src/write.rs
+++ b/packages/signals/src/write.rs
@@ -59,7 +59,7 @@ pub trait Writable: Readable {
 /// # use dioxus::prelude::*;
 /// fn app() -> Element {
 ///     let mut value = use_signal(|| String::from("hello"));
-///     
+///
 ///     rsx! {
 ///         button {
 ///             onclick: move |_| {
diff --git a/packages/stores/src/store.rs b/packages/stores/src/store.rs
index e731d8a4b3..fe56fbdf81 100644
--- a/packages/stores/src/store.rs
+++ b/packages/stores/src/store.rs
@@ -6,9 +6,10 @@ use dioxus_core::{
     use_hook, AttributeValue, DynamicNode, IntoAttributeValue, IntoDynNode, Subscribers, SuperInto,
 };
 use dioxus_signals::{
-    read_impls, write_impls, BorrowError, BorrowMutError, CopyValue, Global,
-    InitializeFromFunction, MappedMutSignal, ReadSignal, Readable, ReadableExt, ReadableRef,
-    Storage, UnsyncStorage, Writable, WritableExt, WritableRef, WriteSignal,
+    read_impls, write_impls, BorrowError, BorrowMutError, CopyValue, CreateReadOnlySignalStorage,
+    Global, InitializeFromFunction, MappedMutSignal, ReadOnlySignalStorage, ReadSignal, Readable,
+    ReadableExt, ReadableRef, Storage, UnsyncStorage, Writable, WritableExt, WritableRef,
+    WriteSignal,
 };
 use std::marker::PhantomData;
 
@@ -21,10 +22,10 @@ pub(crate) type MappedStore<
 > = Store<T, MappedMutSignal<T, Lens, F, FMut>>;
 
 /// A type alias for a boxed read-only store.
-pub type ReadStore<T> = Store<T, ReadSignal<T>>;
+pub type ReadStore<T, S = UnsyncStorage> = Store<T, ReadSignal<T, S>>;
 
 /// A type alias for a boxed writable-only store.
-pub type WriteStore<T> = Store<T, WriteSignal<T>>;
+pub type WriteStore<T, S = UnsyncStorage> = Store<T, WriteSignal<T, S>>;
 
 /// Stores are a reactive type built for nested data structures. Each store will lazily create signals
 /// for each field/member of the data structure as needed.
@@ -181,12 +182,14 @@ where
 }
 impl<T: ?Sized, Lens> Copy for Store<T, Lens> where Lens: Copy {}
 
-impl<__F, __FMut, T: ?Sized, Lens> ::std::convert::From<MappedStore<T, Lens, __F, __FMut>>
-    for Store<T, WriteSignal<T>>
+impl<__F, __FMut, T: ?Sized, S, Lens> ::std::convert::From<MappedStore<T, Lens, __F, __FMut>>
+    for WriteStore<T, S>
 where
-    Lens: Writable<Storage = UnsyncStorage> + 'static,
+    Lens: Writable<Storage = S> + 'static,
     __F: Fn(&Lens::Target) -> &T + 'static,
     __FMut: Fn(&mut Lens::Target) -> &mut T + 'static,
+    S: ReadOnlySignalStorage<T>
+        + CreateReadOnlySignalStorage<MappedMutSignal<T, Lens, __F, __FMut>>,
     T: 'static,
 {
     fn from(value: MappedStore<T, Lens, __F, __FMut>) -> Self {
@@ -196,12 +199,14 @@ where
         }
     }
 }
-impl<__F, __FMut, T: ?Sized, Lens> ::std::convert::From<MappedStore<T, Lens, __F, __FMut>>
-    for Store<T, ReadSignal<T>>
+impl<__F, __FMut, T: ?Sized, S, Lens> ::std::convert::From<MappedStore<T, Lens, __F, __FMut>>
+    for ReadStore<T, S>
 where
-    Lens: Writable<Storage = UnsyncStorage> + 'static,
+    Lens: Writable<Storage = S> + 'static,
     __F: Fn(&Lens::Target) -> &T + 'static,
     __FMut: Fn(&mut Lens::Target) -> &mut T + 'static,
+    S: ReadOnlySignalStorage<T>
+        + CreateReadOnlySignalStorage<MappedMutSignal<T, Lens, __F, __FMut>>,
     T: 'static,
 {
     fn from(value: MappedStore<T, Lens, __F, __FMut>) -> Self {
@@ -211,11 +216,36 @@ where
         }
     }
 }
-impl<T> ::std::convert::From<Store<T>> for ReadStore<T>
+impl<T, S> ::std::convert::From<WriteStore<T, S>> for ReadStore<T, S>
 where
     T: ?Sized + 'static,
+    S: ReadOnlySignalStorage<T> + CreateReadOnlySignalStorage<WriteSignal<T, S>>,
 {
-    fn from(value: Store<T>) -> Self {
+    fn from(value: Store<T, WriteSignal<T, S>>) -> Self {
+        Self {
+            selector: value.selector.map_writer(::std::convert::Into::into),
+            _phantom: ::std::marker::PhantomData,
+        }
+    }
+}
+impl<T, S> ::std::convert::From<Store<T, CopyValue<T, S>>> for ReadStore<T, S>
+where
+    T: 'static,
+    S: ReadOnlySignalStorage<T> + CreateReadOnlySignalStorage<CopyValue<T, S>> + Storage<T>,
+{
+    fn from(value: Store<T, CopyValue<T, S>>) -> Self {
+        Self {
+            selector: value.selector.map_writer(::std::convert::Into::into),
+            _phantom: ::std::marker::PhantomData,
+        }
+    }
+}
+impl<T, S> ::std::convert::From<Store<T, CopyValue<T, S>>> for WriteStore<T, S>
+where
+    T: 'static,
+    S: ReadOnlySignalStorage<T> + CreateReadOnlySignalStorage<CopyValue<T, S>> + Storage<T>,
+{
+    fn from(value: Store<T, CopyValue<T, S>>) -> Self {
         Self {
             selector: value.selector.map_writer(::std::convert::Into::into),
             _phantom: ::std::marker::PhantomData,
@@ -225,25 +255,27 @@ where
 
 #[doc(hidden)]
 pub struct SuperIntoReadSignalMarker;
-impl<T, Lens> SuperInto<ReadSignal<T>, SuperIntoReadSignalMarker> for Store<T, Lens>
+impl<T, S, Lens> SuperInto<ReadSignal<T, S>, SuperIntoReadSignalMarker> for Store<T, Lens>
 where
     T: ?Sized + 'static,
-    Lens: Readable<Target = T, Storage = UnsyncStorage> + 'static,
+    Lens: Readable<Target = T, Storage = S> + 'static,
+    S: CreateReadOnlySignalStorage<Store<T, Lens>> + ReadOnlySignalStorage<T>,
 {
-    fn super_into(self) -> ReadSignal<T> {
-        ReadSignal::new(self)
+    fn super_into(self) -> ReadSignal<T, S> {
+        ReadSignal::new_maybe_sync(self)
     }
 }
 
 #[doc(hidden)]
 pub struct SuperIntoWriteSignalMarker;
-impl<T, Lens> SuperInto<WriteSignal<T>, SuperIntoWriteSignalMarker> for Store<T, Lens>
+impl<T, S, Lens> SuperInto<WriteSignal<T, S>, SuperIntoWriteSignalMarker> for Store<T, Lens>
 where
     T: ?Sized + 'static,
-    Lens: Writable<Target = T, Storage = UnsyncStorage> + 'static,
+    Lens: Writable<Target = T, Storage = S> + 'static,
+    S: CreateReadOnlySignalStorage<Store<T, Lens>> + ReadOnlySignalStorage<T>,
 {
-    fn super_into(self) -> WriteSignal<T> {
-        WriteSignal::new(self)
+    fn super_into(self) -> WriteSignal<T, S> {
+        WriteSignal::new_maybe_sync(self)
     }
 }
 

From 922179976dba5bbf8b7afb995d15fb8d6e688456 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Mon, 25 Aug 2025 11:42:45 -0500
Subject: [PATCH 2/4] seal gats

---
 packages/signals/src/boxed.rs | 143 +++++++++++++++++++---------------
 packages/stores/src/store.rs  |  22 +++---
 2 files changed, 91 insertions(+), 74 deletions(-)

diff --git a/packages/signals/src/boxed.rs b/packages/signals/src/boxed.rs
index b1d3c9ac3a..f5a6a9bf03 100644
--- a/packages/signals/src/boxed.rs
+++ b/packages/signals/src/boxed.rs
@@ -24,54 +24,78 @@ mod sealed {
     impl Sealed for SyncStorage {}
 
     pub struct SealedToken;
+
+    pub trait SealedTokenTrait {}
+    impl SealedTokenTrait for SealedToken {}
 }
 
 /// A trait for creating boxed readable and writable signals. This is implemented for
 /// [UnsyncStorage] and [SyncStorage].
-pub trait ReadOnlySignalStorage<T: ?Sized>:
-    Storage<Box<Self::DynReadable>> + Storage<Box<Self::DynWritable>> + sealed::Sealed + 'static
+///
+/// You may need to add this trait as a bound when you use [ReadSignal] or [WriteSignal] while
+/// remaining generic over syncness.
+pub trait BoxedSignalStorage<T: ?Sized>:
+    Storage<Box<Self::DynReadable<sealed::SealedToken>>>
+    + Storage<Box<Self::DynWritable<sealed::SealedToken>>>
+    + sealed::Sealed
+    + 'static
 {
+    // This is not a public api, and is sealed to prevent external usage and implementations
     #[doc(hidden)]
-    type DynReadable: Readable<Target = T, Storage = Self> + ?Sized;
+    type DynReadable<Seal: sealed::SealedTokenTrait>: Readable<Target = T, Storage = Self> + ?Sized;
+    // This is not a public api, and is sealed to prevent external usage and implementations
     #[doc(hidden)]
-    type DynWritable: Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>> + ?Sized;
+    type DynWritable<Seal: sealed::SealedTokenTrait>: Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>>
+        + ?Sized;
 }
 
 /// A trait for creating boxed readable and writable signals. This is implemented for
 /// [UnsyncStorage] and [SyncStorage].
 ///
-/// The storage type must implement `CreateReadOnlySignalStorage` for the specific readable type
+/// The storage type must implement `CreateReadOnlySignalStorage<T>` for every readable `T` type
 /// to be used with `ReadSignal` and `WriteSignal`.
-pub trait CreateReadOnlySignalStorage<T: Readable + ?Sized>:
-    ReadOnlySignalStorage<T::Target> + 'static
+///
+/// You may need to add this trait as a bound when you call [ReadSignal::new_maybe_sync] or
+/// [WriteSignal::new_maybe_sync] while remaining generic over syncness.
+pub trait CreateBoxedSignalStorage<T: Readable + ?Sized>:
+    BoxedSignalStorage<T::Target> + 'static
 {
+    // This is not a public api, and is sealed to prevent external usage and implementations
     #[doc(hidden)]
-    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable>
+    fn new_readable(
+        value: T,
+        _: sealed::SealedToken,
+    ) -> Box<Self::DynReadable<sealed::SealedToken>>
     where
         T: Sized;
 
+    // This is not a public api, and is sealed to prevent external usage and implementations
     #[doc(hidden)]
-    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable>
+    fn new_writable(
+        value: T,
+        _: sealed::SealedToken,
+    ) -> Box<Self::DynWritable<sealed::SealedToken>>
     where
         T: Writable + Sized;
 }
 
-impl<T: ?Sized + 'static> ReadOnlySignalStorage<T> for UnsyncStorage {
-    type DynReadable = dyn Readable<Target = T, Storage = Self>;
-    type DynWritable = dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>>;
+impl<T: ?Sized + 'static> BoxedSignalStorage<T> for UnsyncStorage {
+    type DynReadable<Seal: sealed::SealedTokenTrait> = dyn Readable<Target = T, Storage = Self>;
+    type DynWritable<Seal: sealed::SealedTokenTrait> =
+        dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>>;
 }
 
-impl<T: Readable<Storage = UnsyncStorage> + ?Sized + 'static> CreateReadOnlySignalStorage<T>
+impl<T: Readable<Storage = UnsyncStorage> + ?Sized + 'static> CreateBoxedSignalStorage<T>
     for UnsyncStorage
 {
-    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable>
+    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable<sealed::SealedToken>>
     where
         T: Sized,
     {
         Box::new(value)
     }
 
-    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable>
+    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable<sealed::SealedToken>>
     where
         T: Writable + Sized,
     {
@@ -79,23 +103,24 @@ impl<T: Readable<Storage = UnsyncStorage> + ?Sized + 'static> CreateReadOnlySign
     }
 }
 
-impl<T: ?Sized + 'static> ReadOnlySignalStorage<T> for SyncStorage {
-    type DynReadable = dyn Readable<Target = T, Storage = Self> + Send + Sync;
-    type DynWritable =
+impl<T: ?Sized + 'static> BoxedSignalStorage<T> for SyncStorage {
+    type DynReadable<Seal: sealed::SealedTokenTrait> =
+        dyn Readable<Target = T, Storage = Self> + Send + Sync;
+    type DynWritable<Seal: sealed::SealedTokenTrait> =
         dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>> + Send + Sync;
 }
 
 impl<T: Readable<Storage = SyncStorage> + Sync + Send + ?Sized + 'static>
-    CreateReadOnlySignalStorage<T> for SyncStorage
+    CreateBoxedSignalStorage<T> for SyncStorage
 {
-    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable>
+    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable<sealed::SealedToken>>
     where
         T: Sized,
     {
         Box::new(value)
     }
 
-    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable>
+    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable<sealed::SealedToken>>
     where
         T: Writable + Sized,
     {
@@ -104,8 +129,8 @@ impl<T: Readable<Storage = SyncStorage> + Sync + Send + ?Sized + 'static>
 }
 
 /// A boxed version of [Readable] that can be used to store any readable type.
-pub struct ReadSignal<T: ?Sized, S: ReadOnlySignalStorage<T> = UnsyncStorage> {
-    value: CopyValue<Box<S::DynReadable>, S>,
+pub struct ReadSignal<T: ?Sized, S: BoxedSignalStorage<T> = UnsyncStorage> {
+    value: CopyValue<Box<S::DynReadable<sealed::SealedToken>>, S>,
 }
 
 impl<T: ?Sized + 'static> ReadSignal<T> {
@@ -115,11 +140,11 @@ impl<T: ?Sized + 'static> ReadSignal<T> {
     }
 }
 
-impl<T: ?Sized + 'static, S: ReadOnlySignalStorage<T>> ReadSignal<T, S> {
+impl<T: ?Sized + 'static, S: BoxedSignalStorage<T>> ReadSignal<T, S> {
     /// Create a new boxed readable value which may be sync
     pub fn new_maybe_sync<R>(value: R) -> Self
     where
-        S: CreateReadOnlySignalStorage<R>,
+        S: CreateBoxedSignalStorage<R>,
         R: Readable<Target = T>,
     {
         Self {
@@ -155,15 +180,15 @@ impl<T: ?Sized + 'static, S: ReadOnlySignalStorage<T>> ReadSignal<T, S> {
     }
 }
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Clone for ReadSignal<T, S> {
+impl<T: ?Sized, S: BoxedSignalStorage<T>> Clone for ReadSignal<T, S> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Copy for ReadSignal<T, S> {}
+impl<T: ?Sized, S: BoxedSignalStorage<T>> Copy for ReadSignal<T, S> {}
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> PartialEq for ReadSignal<T, S> {
+impl<T: ?Sized, S: BoxedSignalStorage<T>> PartialEq for ReadSignal<T, S> {
     fn eq(&self, other: &Self) -> bool {
         self.value == other.value
     }
@@ -171,9 +196,7 @@ impl<T: ?Sized, S: ReadOnlySignalStorage<T>> PartialEq for ReadSignal<T, S> {
 
 impl<
         T: Default + 'static,
-        S: CreateReadOnlySignalStorage<Signal<T, S>>
-            + ReadOnlySignalStorage<T>
-            + Storage<SignalData<T>>,
+        S: CreateBoxedSignalStorage<Signal<T, S>> + BoxedSignalStorage<T> + Storage<SignalData<T>>,
     > Default for ReadSignal<T, S>
 {
     fn default() -> Self {
@@ -181,9 +204,9 @@ impl<
     }
 }
 
-read_impls!(ReadSignal<T, S: ReadOnlySignalStorage<T>>);
+read_impls!(ReadSignal<T, S: BoxedSignalStorage<T>>);
 
-impl<T, S: ReadOnlySignalStorage<T>> IntoAttributeValue for ReadSignal<T, S>
+impl<T, S: BoxedSignalStorage<T>> IntoAttributeValue for ReadSignal<T, S>
 where
     T: Clone + IntoAttributeValue + 'static,
 {
@@ -195,14 +218,14 @@ where
 impl<T, S> IntoDynNode for ReadSignal<T, S>
 where
     T: Clone + IntoDynNode + 'static,
-    S: ReadOnlySignalStorage<T>,
+    S: BoxedSignalStorage<T>,
 {
     fn into_dyn_node(self) -> dioxus_core::DynamicNode {
         self.with(|f| f.clone().into_dyn_node())
     }
 }
 
-impl<T: Clone + 'static, S: ReadOnlySignalStorage<T>> Deref for ReadSignal<T, S> {
+impl<T: Clone + 'static, S: BoxedSignalStorage<T>> Deref for ReadSignal<T, S> {
     type Target = dyn Fn() -> T;
 
     fn deref(&self) -> &Self::Target {
@@ -210,7 +233,7 @@ impl<T: Clone + 'static, S: ReadOnlySignalStorage<T>> Deref for ReadSignal<T, S>
     }
 }
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Readable for ReadSignal<T, S> {
+impl<T: ?Sized, S: BoxedSignalStorage<T>> Readable for ReadSignal<T, S> {
     type Target = T;
     type Storage = S;
 
@@ -251,9 +274,7 @@ impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Readable for ReadSignal<T, S> {
 // all specific readable types
 impl<
         T: 'static,
-        S: CreateReadOnlySignalStorage<Signal<T, S>>
-            + ReadOnlySignalStorage<T>
-            + Storage<SignalData<T>>,
+        S: CreateBoxedSignalStorage<Signal<T, S>> + BoxedSignalStorage<T> + Storage<SignalData<T>>,
     > From<Signal<T, S>> for ReadSignal<T, S>
 {
     fn from(value: Signal<T, S>) -> Self {
@@ -267,7 +288,7 @@ impl<T: PartialEq + 'static> From<Memo<T>> for ReadSignal<T> {
 }
 impl<
         T: 'static,
-        S: CreateReadOnlySignalStorage<CopyValue<T, S>> + ReadOnlySignalStorage<T> + Storage<T>,
+        S: CreateBoxedSignalStorage<CopyValue<T, S>> + BoxedSignalStorage<T> + Storage<T>,
     > From<CopyValue<T, S>> for ReadSignal<T, S>
 {
     fn from(value: CopyValue<T, S>) -> Self {
@@ -288,7 +309,7 @@ where
     O: ?Sized + 'static,
     V: Readable<Storage = S> + 'static,
     F: Fn(&V::Target) -> &O + 'static,
-    S: ReadOnlySignalStorage<O> + CreateReadOnlySignalStorage<MappedSignal<O, V, F>>,
+    S: BoxedSignalStorage<O> + CreateBoxedSignalStorage<MappedSignal<O, V, F>>,
 {
     fn from(value: MappedSignal<O, V, F>) -> Self {
         Self::new_maybe_sync(value)
@@ -300,7 +321,7 @@ where
     V: Readable<Storage = S> + 'static,
     F: Fn(&V::Target) -> &O + 'static,
     FMut: 'static,
-    S: ReadOnlySignalStorage<O> + CreateReadOnlySignalStorage<MappedMutSignal<O, V, F, FMut>>,
+    S: BoxedSignalStorage<O> + CreateBoxedSignalStorage<MappedMutSignal<O, V, F, FMut>>,
 {
     fn from(value: MappedMutSignal<O, V, F, FMut>) -> Self {
         Self::new_maybe_sync(value)
@@ -308,7 +329,7 @@ where
 }
 impl<T: ?Sized + 'static, S> From<WriteSignal<T, S>> for ReadSignal<T, S>
 where
-    S: ReadOnlySignalStorage<T> + CreateReadOnlySignalStorage<WriteSignal<T, S>>,
+    S: BoxedSignalStorage<T> + CreateBoxedSignalStorage<WriteSignal<T, S>>,
 {
     fn from(value: WriteSignal<T, S>) -> Self {
         Self::new_maybe_sync(value)
@@ -316,8 +337,8 @@ where
 }
 
 /// A boxed version of [Writable] that can be used to store any writable type.
-pub struct WriteSignal<T: ?Sized, S: ReadOnlySignalStorage<T> = UnsyncStorage> {
-    value: CopyValue<Box<S::DynWritable>, S>,
+pub struct WriteSignal<T: ?Sized, S: BoxedSignalStorage<T> = UnsyncStorage> {
+    value: CopyValue<Box<S::DynWritable<sealed::SealedToken>>, S>,
 }
 
 impl<T: ?Sized + 'static> WriteSignal<T> {
@@ -329,12 +350,12 @@ impl<T: ?Sized + 'static> WriteSignal<T> {
     }
 }
 
-impl<T: ?Sized + 'static, S: ReadOnlySignalStorage<T>> WriteSignal<T, S> {
+impl<T: ?Sized + 'static, S: BoxedSignalStorage<T>> WriteSignal<T, S> {
     /// Create a new boxed writable value which may be sync
     pub fn new_maybe_sync<R>(value: R) -> Self
     where
         R: Writable<Target = T, WriteMetadata: 'static>,
-        S: CreateReadOnlySignalStorage<R>,
+        S: CreateBoxedSignalStorage<R>,
     {
         Self {
             value: CopyValue::new_maybe_sync(S::new_writable(value, sealed::SealedToken)),
@@ -402,27 +423,27 @@ where
     }
 }
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Clone for WriteSignal<T, S> {
+impl<T: ?Sized, S: BoxedSignalStorage<T>> Clone for WriteSignal<T, S> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Copy for WriteSignal<T, S> {}
+impl<T: ?Sized, S: BoxedSignalStorage<T>> Copy for WriteSignal<T, S> {}
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> PartialEq for WriteSignal<T, S> {
+impl<T: ?Sized, S: BoxedSignalStorage<T>> PartialEq for WriteSignal<T, S> {
     fn eq(&self, other: &Self) -> bool {
         self.value == other.value
     }
 }
 
-read_impls!(WriteSignal<T, S: ReadOnlySignalStorage<T>>);
-write_impls!(WriteSignal<T, S: ReadOnlySignalStorage<T>>);
+read_impls!(WriteSignal<T, S: BoxedSignalStorage<T>>);
+write_impls!(WriteSignal<T, S: BoxedSignalStorage<T>>);
 
 impl<T, S> IntoAttributeValue for WriteSignal<T, S>
 where
     T: Clone + IntoAttributeValue + 'static,
-    S: ReadOnlySignalStorage<T>,
+    S: BoxedSignalStorage<T>,
 {
     fn into_value(self) -> dioxus_core::AttributeValue {
         self.with(|f| f.clone().into_value())
@@ -432,14 +453,14 @@ where
 impl<T, S> IntoDynNode for WriteSignal<T, S>
 where
     T: Clone + IntoDynNode + 'static,
-    S: ReadOnlySignalStorage<T>,
+    S: BoxedSignalStorage<T>,
 {
     fn into_dyn_node(self) -> dioxus_core::DynamicNode {
         self.with(|f| f.clone().into_dyn_node())
     }
 }
 
-impl<T: Clone + 'static, S: ReadOnlySignalStorage<T>> Deref for WriteSignal<T, S> {
+impl<T: Clone + 'static, S: BoxedSignalStorage<T>> Deref for WriteSignal<T, S> {
     type Target = dyn Fn() -> T;
 
     fn deref(&self) -> &Self::Target {
@@ -447,7 +468,7 @@ impl<T: Clone + 'static, S: ReadOnlySignalStorage<T>> Deref for WriteSignal<T, S
     }
 }
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Readable for WriteSignal<T, S> {
+impl<T: ?Sized, S: BoxedSignalStorage<T>> Readable for WriteSignal<T, S> {
     type Target = T;
     type Storage = S;
 
@@ -483,7 +504,7 @@ impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Readable for WriteSignal<T, S> {
     }
 }
 
-impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Writable for WriteSignal<T, S> {
+impl<T: ?Sized, S: BoxedSignalStorage<T>> Writable for WriteSignal<T, S> {
     type WriteMetadata = Box<dyn Any>;
 
     fn try_write_unchecked(
@@ -504,9 +525,7 @@ impl<T: ?Sized, S: ReadOnlySignalStorage<T>> Writable for WriteSignal<T, S> {
 // all specific readable types
 impl<
         T: 'static,
-        S: CreateReadOnlySignalStorage<Signal<T, S>>
-            + ReadOnlySignalStorage<T>
-            + Storage<SignalData<T>>,
+        S: CreateBoxedSignalStorage<Signal<T, S>> + BoxedSignalStorage<T> + Storage<SignalData<T>>,
     > From<Signal<T, S>> for WriteSignal<T, S>
 {
     fn from(value: Signal<T, S>) -> Self {
@@ -515,7 +534,7 @@ impl<
 }
 impl<
         T: 'static,
-        S: CreateReadOnlySignalStorage<CopyValue<T, S>> + ReadOnlySignalStorage<T> + Storage<T>,
+        S: CreateBoxedSignalStorage<CopyValue<T, S>> + BoxedSignalStorage<T> + Storage<T>,
     > From<CopyValue<T, S>> for WriteSignal<T, S>
 {
     fn from(value: CopyValue<T, S>) -> Self {
@@ -537,7 +556,7 @@ where
     V: Writable<Storage = S> + 'static,
     F: Fn(&V::Target) -> &O + 'static,
     FMut: Fn(&mut V::Target) -> &mut O + 'static,
-    S: CreateReadOnlySignalStorage<MappedMutSignal<O, V, F, FMut>> + ReadOnlySignalStorage<O>,
+    S: CreateBoxedSignalStorage<MappedMutSignal<O, V, F, FMut>> + BoxedSignalStorage<O>,
 {
     fn from(value: MappedMutSignal<O, V, F, FMut>) -> Self {
         Self::new_maybe_sync(value)
diff --git a/packages/stores/src/store.rs b/packages/stores/src/store.rs
index fe56fbdf81..cfc420ed54 100644
--- a/packages/stores/src/store.rs
+++ b/packages/stores/src/store.rs
@@ -6,9 +6,9 @@ use dioxus_core::{
     use_hook, AttributeValue, DynamicNode, IntoAttributeValue, IntoDynNode, Subscribers, SuperInto,
 };
 use dioxus_signals::{
-    read_impls, write_impls, BorrowError, BorrowMutError, CopyValue, CreateReadOnlySignalStorage,
-    Global, InitializeFromFunction, MappedMutSignal, ReadOnlySignalStorage, ReadSignal, Readable,
-    ReadableExt, ReadableRef, Storage, UnsyncStorage, Writable, WritableExt, WritableRef,
+    read_impls, write_impls, BorrowError, BorrowMutError, BoxedSignalStorage, CopyValue,
+    CreateBoxedSignalStorage, Global, InitializeFromFunction, MappedMutSignal, ReadSignal,
+    Readable, ReadableExt, ReadableRef, Storage, UnsyncStorage, Writable, WritableExt, WritableRef,
     WriteSignal,
 };
 use std::marker::PhantomData;
@@ -188,8 +188,7 @@ where
     Lens: Writable<Storage = S> + 'static,
     __F: Fn(&Lens::Target) -> &T + 'static,
     __FMut: Fn(&mut Lens::Target) -> &mut T + 'static,
-    S: ReadOnlySignalStorage<T>
-        + CreateReadOnlySignalStorage<MappedMutSignal<T, Lens, __F, __FMut>>,
+    S: BoxedSignalStorage<T> + CreateBoxedSignalStorage<MappedMutSignal<T, Lens, __F, __FMut>>,
     T: 'static,
 {
     fn from(value: MappedStore<T, Lens, __F, __FMut>) -> Self {
@@ -205,8 +204,7 @@ where
     Lens: Writable<Storage = S> + 'static,
     __F: Fn(&Lens::Target) -> &T + 'static,
     __FMut: Fn(&mut Lens::Target) -> &mut T + 'static,
-    S: ReadOnlySignalStorage<T>
-        + CreateReadOnlySignalStorage<MappedMutSignal<T, Lens, __F, __FMut>>,
+    S: BoxedSignalStorage<T> + CreateBoxedSignalStorage<MappedMutSignal<T, Lens, __F, __FMut>>,
     T: 'static,
 {
     fn from(value: MappedStore<T, Lens, __F, __FMut>) -> Self {
@@ -219,7 +217,7 @@ where
 impl<T, S> ::std::convert::From<WriteStore<T, S>> for ReadStore<T, S>
 where
     T: ?Sized + 'static,
-    S: ReadOnlySignalStorage<T> + CreateReadOnlySignalStorage<WriteSignal<T, S>>,
+    S: BoxedSignalStorage<T> + CreateBoxedSignalStorage<WriteSignal<T, S>>,
 {
     fn from(value: Store<T, WriteSignal<T, S>>) -> Self {
         Self {
@@ -231,7 +229,7 @@ where
 impl<T, S> ::std::convert::From<Store<T, CopyValue<T, S>>> for ReadStore<T, S>
 where
     T: 'static,
-    S: ReadOnlySignalStorage<T> + CreateReadOnlySignalStorage<CopyValue<T, S>> + Storage<T>,
+    S: BoxedSignalStorage<T> + CreateBoxedSignalStorage<CopyValue<T, S>> + Storage<T>,
 {
     fn from(value: Store<T, CopyValue<T, S>>) -> Self {
         Self {
@@ -243,7 +241,7 @@ where
 impl<T, S> ::std::convert::From<Store<T, CopyValue<T, S>>> for WriteStore<T, S>
 where
     T: 'static,
-    S: ReadOnlySignalStorage<T> + CreateReadOnlySignalStorage<CopyValue<T, S>> + Storage<T>,
+    S: BoxedSignalStorage<T> + CreateBoxedSignalStorage<CopyValue<T, S>> + Storage<T>,
 {
     fn from(value: Store<T, CopyValue<T, S>>) -> Self {
         Self {
@@ -259,7 +257,7 @@ impl<T, S, Lens> SuperInto<ReadSignal<T, S>, SuperIntoReadSignalMarker> for Stor
 where
     T: ?Sized + 'static,
     Lens: Readable<Target = T, Storage = S> + 'static,
-    S: CreateReadOnlySignalStorage<Store<T, Lens>> + ReadOnlySignalStorage<T>,
+    S: CreateBoxedSignalStorage<Store<T, Lens>> + BoxedSignalStorage<T>,
 {
     fn super_into(self) -> ReadSignal<T, S> {
         ReadSignal::new_maybe_sync(self)
@@ -272,7 +270,7 @@ impl<T, S, Lens> SuperInto<WriteSignal<T, S>, SuperIntoWriteSignalMarker> for St
 where
     T: ?Sized + 'static,
     Lens: Writable<Target = T, Storage = S> + 'static,
-    S: CreateReadOnlySignalStorage<Store<T, Lens>> + ReadOnlySignalStorage<T>,
+    S: CreateBoxedSignalStorage<Store<T, Lens>> + BoxedSignalStorage<T>,
 {
     fn super_into(self) -> WriteSignal<T, S> {
         WriteSignal::new_maybe_sync(self)

From bb838f6ecc12c02b3270565f6095158299b0b111 Mon Sep 17 00:00:00 2001
From: Evan Almloff <evanalmloff@gmail.com>
Date: Mon, 25 Aug 2025 11:50:02 -0500
Subject: [PATCH 3/4] minimize diff

---
 packages/signals/examples/send.rs | 14 ++++----------
 packages/signals/src/write.rs     |  2 +-
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/packages/signals/examples/send.rs b/packages/signals/examples/send.rs
index b55d2952f9..3591d9f058 100644
--- a/packages/signals/examples/send.rs
+++ b/packages/signals/examples/send.rs
@@ -7,15 +7,6 @@ fn main() {
 fn app() -> Element {
     let mut signal = use_signal_sync(|| 0);
 
-    rsx! {
-        button { onclick: move |_| signal += 1, "Increase" }
-        "{signal}"
-        Child { signal }
-    }
-}
-
-#[component]
-fn Child(signal: WriteSignal<u32, SyncStorage>) -> Element {
     use_hook(|| {
         std::thread::spawn(move || loop {
             std::thread::sleep(std::time::Duration::from_secs(1));
@@ -23,5 +14,8 @@ fn Child(signal: WriteSignal<u32, SyncStorage>) -> Element {
         });
     });
 
-    rsx! {}
+    rsx! {
+        button { onclick: move |_| signal += 1, "Increase" }
+        "{signal}"
+    }
 }
diff --git a/packages/signals/src/write.rs b/packages/signals/src/write.rs
index 098ee6561d..461ca6ef95 100644
--- a/packages/signals/src/write.rs
+++ b/packages/signals/src/write.rs
@@ -59,7 +59,7 @@ pub trait Writable: Readable {
 /// # use dioxus::prelude::*;
 /// fn app() -> Element {
 ///     let mut value = use_signal(|| String::from("hello"));
-///
+///     
 ///     rsx! {
 ///         button {
 ///             onclick: move |_| {

From c6cb92f98fda29f81b98c572e4f6ece1e956cd49 Mon Sep 17 00:00:00 2001
From: Jonathan Kelley <jkelleyrtp@gmail.com>
Date: Fri, 3 Oct 2025 20:05:27 -0700
Subject: [PATCH 4/4] change order for clairty

---
 packages/signals/examples/send_store.rs |   6 +
 packages/signals/src/boxed.rs           | 224 ++++++++++++------------
 2 files changed, 118 insertions(+), 112 deletions(-)

diff --git a/packages/signals/examples/send_store.rs b/packages/signals/examples/send_store.rs
index 60768c6c21..9b6f807e39 100644
--- a/packages/signals/examples/send_store.rs
+++ b/packages/signals/examples/send_store.rs
@@ -16,10 +16,16 @@ fn app() -> Element {
 
 #[component]
 fn Child(store: WriteStore<u32, SyncStorage>) -> Element {
+    // A `WriteStore<T, SyncStorage>` can be sent to another thread!
+    // Make sure to clean up your threads when the component unmounts.
     use_hook(|| {
         std::thread::spawn(move || loop {
             std::thread::sleep(std::time::Duration::from_secs(1));
             store += 1;
+
+            if store() >= 10 {
+                break;
+            }
         });
     });
 
diff --git a/packages/signals/src/boxed.rs b/packages/signals/src/boxed.rs
index f5a6a9bf03..8868623b37 100644
--- a/packages/signals/src/boxed.rs
+++ b/packages/signals/src/boxed.rs
@@ -16,118 +16,6 @@ use crate::{
 )]
 pub type ReadOnlySignal<T, S> = ReadSignal<T, S>;
 
-mod sealed {
-    use generational_box::{SyncStorage, UnsyncStorage};
-
-    pub trait Sealed {}
-    impl Sealed for UnsyncStorage {}
-    impl Sealed for SyncStorage {}
-
-    pub struct SealedToken;
-
-    pub trait SealedTokenTrait {}
-    impl SealedTokenTrait for SealedToken {}
-}
-
-/// A trait for creating boxed readable and writable signals. This is implemented for
-/// [UnsyncStorage] and [SyncStorage].
-///
-/// You may need to add this trait as a bound when you use [ReadSignal] or [WriteSignal] while
-/// remaining generic over syncness.
-pub trait BoxedSignalStorage<T: ?Sized>:
-    Storage<Box<Self::DynReadable<sealed::SealedToken>>>
-    + Storage<Box<Self::DynWritable<sealed::SealedToken>>>
-    + sealed::Sealed
-    + 'static
-{
-    // This is not a public api, and is sealed to prevent external usage and implementations
-    #[doc(hidden)]
-    type DynReadable<Seal: sealed::SealedTokenTrait>: Readable<Target = T, Storage = Self> + ?Sized;
-    // This is not a public api, and is sealed to prevent external usage and implementations
-    #[doc(hidden)]
-    type DynWritable<Seal: sealed::SealedTokenTrait>: Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>>
-        + ?Sized;
-}
-
-/// A trait for creating boxed readable and writable signals. This is implemented for
-/// [UnsyncStorage] and [SyncStorage].
-///
-/// The storage type must implement `CreateReadOnlySignalStorage<T>` for every readable `T` type
-/// to be used with `ReadSignal` and `WriteSignal`.
-///
-/// You may need to add this trait as a bound when you call [ReadSignal::new_maybe_sync] or
-/// [WriteSignal::new_maybe_sync] while remaining generic over syncness.
-pub trait CreateBoxedSignalStorage<T: Readable + ?Sized>:
-    BoxedSignalStorage<T::Target> + 'static
-{
-    // This is not a public api, and is sealed to prevent external usage and implementations
-    #[doc(hidden)]
-    fn new_readable(
-        value: T,
-        _: sealed::SealedToken,
-    ) -> Box<Self::DynReadable<sealed::SealedToken>>
-    where
-        T: Sized;
-
-    // This is not a public api, and is sealed to prevent external usage and implementations
-    #[doc(hidden)]
-    fn new_writable(
-        value: T,
-        _: sealed::SealedToken,
-    ) -> Box<Self::DynWritable<sealed::SealedToken>>
-    where
-        T: Writable + Sized;
-}
-
-impl<T: ?Sized + 'static> BoxedSignalStorage<T> for UnsyncStorage {
-    type DynReadable<Seal: sealed::SealedTokenTrait> = dyn Readable<Target = T, Storage = Self>;
-    type DynWritable<Seal: sealed::SealedTokenTrait> =
-        dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>>;
-}
-
-impl<T: Readable<Storage = UnsyncStorage> + ?Sized + 'static> CreateBoxedSignalStorage<T>
-    for UnsyncStorage
-{
-    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable<sealed::SealedToken>>
-    where
-        T: Sized,
-    {
-        Box::new(value)
-    }
-
-    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable<sealed::SealedToken>>
-    where
-        T: Writable + Sized,
-    {
-        Box::new(BoxWriteMetadata::new(value))
-    }
-}
-
-impl<T: ?Sized + 'static> BoxedSignalStorage<T> for SyncStorage {
-    type DynReadable<Seal: sealed::SealedTokenTrait> =
-        dyn Readable<Target = T, Storage = Self> + Send + Sync;
-    type DynWritable<Seal: sealed::SealedTokenTrait> =
-        dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>> + Send + Sync;
-}
-
-impl<T: Readable<Storage = SyncStorage> + Sync + Send + ?Sized + 'static>
-    CreateBoxedSignalStorage<T> for SyncStorage
-{
-    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable<sealed::SealedToken>>
-    where
-        T: Sized,
-    {
-        Box::new(value)
-    }
-
-    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable<sealed::SealedToken>>
-    where
-        T: Writable + Sized,
-    {
-        Box::new(BoxWriteMetadata::new(value))
-    }
-}
-
 /// A boxed version of [Readable] that can be used to store any readable type.
 pub struct ReadSignal<T: ?Sized, S: BoxedSignalStorage<T> = UnsyncStorage> {
     value: CopyValue<Box<S::DynReadable<sealed::SealedToken>>, S>,
@@ -562,3 +450,115 @@ where
         Self::new_maybe_sync(value)
     }
 }
+
+/// A trait for creating boxed readable and writable signals. This is implemented for
+/// [UnsyncStorage] and [SyncStorage].
+///
+/// You may need to add this trait as a bound when you use [ReadSignal] or [WriteSignal] while
+/// remaining generic over syncness.
+pub trait BoxedSignalStorage<T: ?Sized>:
+    Storage<Box<Self::DynReadable<sealed::SealedToken>>>
+    + Storage<Box<Self::DynWritable<sealed::SealedToken>>>
+    + sealed::Sealed
+    + 'static
+{
+    // This is not a public api, and is sealed to prevent external usage and implementations
+    #[doc(hidden)]
+    type DynReadable<Seal: sealed::SealedTokenTrait>: Readable<Target = T, Storage = Self> + ?Sized;
+    // This is not a public api, and is sealed to prevent external usage and implementations
+    #[doc(hidden)]
+    type DynWritable<Seal: sealed::SealedTokenTrait>: Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>>
+        + ?Sized;
+}
+
+/// A trait for creating boxed readable and writable signals. This is implemented for
+/// [UnsyncStorage] and [SyncStorage].
+///
+/// The storage type must implement `CreateReadOnlySignalStorage<T>` for every readable `T` type
+/// to be used with `ReadSignal` and `WriteSignal`.
+///
+/// You may need to add this trait as a bound when you call [ReadSignal::new_maybe_sync] or
+/// [WriteSignal::new_maybe_sync] while remaining generic over syncness.
+pub trait CreateBoxedSignalStorage<T: Readable + ?Sized>:
+    BoxedSignalStorage<T::Target> + 'static
+{
+    // This is not a public api, and is sealed to prevent external usage and implementations
+    #[doc(hidden)]
+    fn new_readable(
+        value: T,
+        _: sealed::SealedToken,
+    ) -> Box<Self::DynReadable<sealed::SealedToken>>
+    where
+        T: Sized;
+
+    // This is not a public api, and is sealed to prevent external usage and implementations
+    #[doc(hidden)]
+    fn new_writable(
+        value: T,
+        _: sealed::SealedToken,
+    ) -> Box<Self::DynWritable<sealed::SealedToken>>
+    where
+        T: Writable + Sized;
+}
+
+impl<T: ?Sized + 'static> BoxedSignalStorage<T> for UnsyncStorage {
+    type DynReadable<Seal: sealed::SealedTokenTrait> = dyn Readable<Target = T, Storage = Self>;
+    type DynWritable<Seal: sealed::SealedTokenTrait> =
+        dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>>;
+}
+
+impl<T: Readable<Storage = UnsyncStorage> + ?Sized + 'static> CreateBoxedSignalStorage<T>
+    for UnsyncStorage
+{
+    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable<sealed::SealedToken>>
+    where
+        T: Sized,
+    {
+        Box::new(value)
+    }
+
+    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable<sealed::SealedToken>>
+    where
+        T: Writable + Sized,
+    {
+        Box::new(BoxWriteMetadata::new(value))
+    }
+}
+
+impl<T: ?Sized + 'static> BoxedSignalStorage<T> for SyncStorage {
+    type DynReadable<Seal: sealed::SealedTokenTrait> =
+        dyn Readable<Target = T, Storage = Self> + Send + Sync;
+    type DynWritable<Seal: sealed::SealedTokenTrait> =
+        dyn Writable<Target = T, Storage = Self, WriteMetadata = Box<dyn Any>> + Send + Sync;
+}
+
+impl<T: Readable<Storage = SyncStorage> + Sync + Send + ?Sized + 'static>
+    CreateBoxedSignalStorage<T> for SyncStorage
+{
+    fn new_readable(value: T, _: sealed::SealedToken) -> Box<Self::DynReadable<sealed::SealedToken>>
+    where
+        T: Sized,
+    {
+        Box::new(value)
+    }
+
+    fn new_writable(value: T, _: sealed::SealedToken) -> Box<Self::DynWritable<sealed::SealedToken>>
+    where
+        T: Writable + Sized,
+    {
+        Box::new(BoxWriteMetadata::new(value))
+    }
+}
+
+mod sealed {
+    use generational_box::{SyncStorage, UnsyncStorage};
+
+    pub trait Sealed {}
+    impl Sealed for UnsyncStorage {}
+    impl Sealed for SyncStorage {}
+
+    pub struct SealedToken;
+
+    pub trait SealedTokenTrait {}
+    impl SealedTokenTrait for SealedToken {}
+}