fix: ensure that store subfield mutations notify from the root down (closes #3704)

`ImmediateEffect` follow up

.github/workflows/ci-semver.yml

@@ -18,7 +18,7 @@ jobs:
   test:
     needs: [get-leptos-changed]
     if: needs.get-leptos-changed.outputs.leptos_changed == 'true' && github.event.pull_request.labels[0].name != 'breaking'
-    name: Run semver check (nightly-2024-08-01)
+    name: Run semver check (nightly-2025-03-05)
     runs-on: ubuntu-latest
     steps:
       - name: Install Glib
@@ -30,4 +30,4 @@ jobs:
       - name: Semver Checks
         uses: obi1kenobi/cargo-semver-checks-action@v2
         with:
-          rust-toolchain: nightly-2024-08-01
+          rust-toolchain: nightly-2025-03-05

.github/workflows/ci.yml

@@ -26,4 +26,4 @@ jobs:
     with:
       directory: ${{ matrix.directory }}
       cargo_make_task: "ci"
-      toolchain: nightly-2024-08-01
+      toolchain: nightly-2025-03-05

.github/workflows/run-cargo-make-task.yml

@@ -55,7 +55,7 @@ jobs:
       - name: Install wasm-bindgen
         run: cargo binstall wasm-bindgen-cli --no-confirm
       - name: Install cargo-leptos
-        run: cargo binstall cargo-leptos --no-confirm
+        run: cargo binstall cargo-leptos --locked --no-confirm
       - name: Install Trunk
         uses: jetli/trunk-action@v0.5.0
         with:

Cargo.toml

@@ -40,7 +40,7 @@ members = [
 exclude = ["benchmarks", "examples", "projects"]
 
 [workspace.package]
-version = "0.7.5"
+version = "0.7.7"
 edition = "2021"
 rust-version = "1.76"
 
@@ -48,28 +48,31 @@ rust-version = "1.76"
 throw_error = { path = "./any_error/", version = "0.2.0" }
 any_spawner = { path = "./any_spawner/", version = "0.2.0" }
 const_str_slice_concat = { path = "./const_str_slice_concat", version = "0.1" }
-either_of = { path = "./either_of/", version = "0.1.0" }
+either_of = { path = "./either_of/", version = "0.1.5" }
 hydration_context = { path = "./hydration_context", version = "0.2.0" }
-leptos = { path = "./leptos", version = "0.7.5" }
-leptos_config = { path = "./leptos_config", version = "0.7.5" }
-leptos_dom = { path = "./leptos_dom", version = "0.7.5" }
-leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.7.5" }
-leptos_integration_utils = { path = "./integrations/utils", version = "0.7.5" }
-leptos_macro = { path = "./leptos_macro", version = "0.7.5" }
-leptos_router = { path = "./router", version = "0.7.5" }
-leptos_router_macro = { path = "./router_macro", version = "0.7.5" }
-leptos_server = { path = "./leptos_server", version = "0.7.5" }
-leptos_meta = { path = "./meta", version = "0.7.5" }
+itertools = "0.14.0"
+leptos = { path = "./leptos", version = "0.7.7" }
+leptos_config = { path = "./leptos_config", version = "0.7.7" }
+leptos_dom = { path = "./leptos_dom", version = "0.7.7" }
+leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.7.7" }
+leptos_integration_utils = { path = "./integrations/utils", version = "0.7.7" }
+leptos_macro = { path = "./leptos_macro", version = "0.7.7" }
+leptos_router = { path = "./router", version = "0.7.7" }
+leptos_router_macro = { path = "./router_macro", version = "0.7.7" }
+leptos_server = { path = "./leptos_server", version = "0.7.7" }
+leptos_meta = { path = "./meta", version = "0.7.7" }
 next_tuple = { path = "./next_tuple", version = "0.1.0" }
 oco_ref = { path = "./oco", version = "0.2.0" }
 or_poisoned = { path = "./or_poisoned", version = "0.1.0" }
-reactive_graph = { path = "./reactive_graph", version = "0.1.5" }
-reactive_stores = { path = "./reactive_stores", version = "0.1.3" }
-reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.1.0" }
-server_fn = { path = "./server_fn", version = "0.7.5" }
-server_fn_macro = { path = "./server_fn_macro", version = "0.7.5" }
-server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.7.5" }
-tachys = { path = "./tachys", version = "0.1.5" }
+reactive_graph = { path = "./reactive_graph", version = "0.1.7" }
+reactive_stores = { path = "./reactive_stores", version = "0.1.7" }
+reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.1.7" }
+serde_json = "1.0.0"
+server_fn = { path = "./server_fn", version = "0.7.7" }
+server_fn_macro = { path = "./server_fn_macro", version = "0.7.7" }
+server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.7.7" }
+tachys = { path = "./tachys", version = "0.1.7" }
+wasm-bindgen = { version = "0.2.100" }
 
 [profile.release]
 codegen-units = 1

README.md

@@ -21,7 +21,7 @@ use leptos::*;
 #[component]
 pub fn SimpleCounter(initial_value: i32) -> impl IntoView {
     // create a reactive signal with the initial value
-    let (value, set_value) = create_signal(initial_value);
+    let (value, set_value) = signal(initial_value);
 
     // create event handlers for our buttons
     // note that `value` and `set_value` are `Copy`, so it's super easy to move them into closures
@@ -46,7 +46,7 @@ pub fn SimpleCounter(initial_value: i32) -> impl IntoView {
 pub fn SimpleCounterWithBuilder(initial_value: i32) -> impl IntoView {
     use leptos::html::*;
 
-    let (value, set_value) = create_signal(initial_value);
+    let (value, set_value) = signal(initial_value);
     let clear = move |_| set_value(0);
     let decrement = move |_| set_value.update(|value| *value -= 1);
     let increment = move |_| set_value.update(|value| *value += 1);

any_error/src/lib.rs

@@ -9,7 +9,7 @@ use std::{
     error,
     fmt::{self, Display},
     future::Future,
-    mem, ops,
+    ops,
     pin::Pin,
     sync::Arc,
     task::{Context, Poll},
@@ -109,7 +109,7 @@ pub fn get_error_hook() -> Option<Arc<dyn ErrorHook>> {
 /// Sets the current thread-local error hook, which will be invoked when [`throw`] is called.
 pub fn set_error_hook(hook: Arc<dyn ErrorHook>) -> ResetErrorHookOnDrop {
     ResetErrorHookOnDrop(
-        ERROR_HOOK.with_borrow_mut(|this| mem::replace(this, Some(hook))),
+        ERROR_HOOK.with_borrow_mut(|this| Option::replace(this, hook)),
     )
 }
 

any_spawner/Cargo.toml

@@ -17,7 +17,7 @@ tokio = { version = "1.41", optional = true, default-features = false, features
   "rt",
 ] }
 tracing = { version = "0.1.41", optional = true }
-wasm-bindgen-futures = { version = "0.4.47", optional = true }
+wasm-bindgen-futures = { version = "0.4.50", optional = true }
 
 [features]
 async-executor = ["dep:async-executor"]

benchmarks/Cargo.toml

@@ -23,7 +23,7 @@ tokio-test = "0.4.0"
 miniserde = "0.1.0"
 gloo = "0.8.0"
 uuid = { version = "1.0", features = ["serde", "v4", "wasm-bindgen"] }
-wasm-bindgen = "0.2.0"
+wasm-bindgen = "0.2.100"
 lazy_static = "1.0"
 log = "0.4.0"
 strum = "0.24.0"

examples/cargo-make/cargo-leptos.toml

@@ -1,5 +1,6 @@
 [tasks.install-cargo-leptos]
 install_crate = { crate_name = "cargo-leptos", binary = "cargo-leptos", test_arg = "--help" }
+args = ["--locked"]
 
 [tasks.cargo-leptos-e2e]
 command = "cargo"

examples/server_fns_axum/Cargo.toml

@@ -22,20 +22,20 @@ log = "0.4.22"
 simple_logger = "5.0"
 serde = { version = "1.0", features = ["derive"] }
 axum = { version = "0.7.5", optional = true }
-tower = { version = "0.4.13", optional = true }
-tower-http = { version = "0.5.2", features = [
+tower = { version = "0.5.2", optional = true }
+tower-http = { version = "0.6.2", features = [
   "fs",
   "tracing",
   "trace",
 ], optional = true }
 tokio = { version = "1.39", features = ["full"], optional = true }
-thiserror = "1.0"
+thiserror = "2.0.11"
 wasm-bindgen = "0.2.93"
 serde_toml = "0.0.1"
 toml = "0.8.19"
 web-sys = { version = "0.3.70", features = ["FileList", "File"] }
-strum = { version = "0.26.3", features = ["strum_macros", "derive"] }
-notify = { version = "6.1", optional = true }
+strum = { version = "0.27.1", features = ["strum_macros", "derive"] }
+notify = { version = "8.0", optional = true }
 pin-project-lite = "0.2.14"
 dashmap = { version = "6.0", optional = true }
 once_cell = { version = "1.19", optional = true }

examples/spread/rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "nightly-2024-01-29"
+channel = "nightly-2025-03-05"

hydration_context/Cargo.toml

@@ -14,7 +14,7 @@ throw_error = { workspace = true }
 or_poisoned = { workspace = true }
 futures = "0.3.31"
 serde = { version = "1.0", features = ["derive"] }
-wasm-bindgen = { version = "0.2.97", optional = true }
+wasm-bindgen = { version = "0.2.100", optional = true }
 js-sys = { version = "0.3.74", optional = true }
 once_cell = "1.20"
 pin-project-lite = "0.2.15"

integrations/actix/Cargo.toml

@@ -21,10 +21,10 @@ leptos_macro = { workspace = true, features = ["actix"] }
 leptos_meta = { workspace = true, features = ["nonce"] }
 leptos_router = { workspace = true, features = ["ssr"] }
 server_fn = { workspace = true, features = ["actix"] }
-serde_json = "1.0"
+serde_json = { workspace = true }
 parking_lot = "0.12.3"
 tracing = { version = "0.1", optional = true }
-tokio = { version = "1.41", features = ["rt", "fs"] }
+tokio = { version = "1.43", features = ["rt", "fs"] }
 send_wrapper = "0.6.0"
 dashmap = "6"
 once_cell = "1"

integrations/actix/src/lib.rs

@@ -274,14 +274,13 @@ pub fn redirect(path: &str) {
 ///
 /// This can then be set up at an appropriate route in your application:
 ///
-/// ```
+/// ```no_run
 /// use actix_web::*;
 ///
 /// fn register_server_functions() {
 ///   // call ServerFn::register() for each of the server functions you've defined
 /// }
 ///
-/// # if false { // don't actually try to run a server in a doctest...
 /// #[actix_web::main]
 /// async fn main() -> std::io::Result<()> {
 ///     // make sure you actually register your server functions
@@ -297,7 +296,6 @@ pub fn redirect(path: &str) {
 ///     .run()
 ///     .await
 /// }
-/// # }
 /// ```
 ///
 /// ## Provided Context Types
@@ -433,7 +431,7 @@ pub fn handle_server_fns_with_context(
 /// but requires some client-side JavaScript.
 ///
 /// This can then be set up at an appropriate route in your application:
-/// ```
+/// ```no_run
 /// use actix_web::{App, HttpServer};
 /// use leptos::prelude::*;
 /// use leptos_router::Method;
@@ -444,7 +442,6 @@ pub fn handle_server_fns_with_context(
 ///     view! { <main>"Hello, world!"</main> }
 /// }
 ///
-/// # if false { // don't actually try to run a server in a doctest...
 /// #[actix_web::main]
 /// async fn main() -> std::io::Result<()> {
 ///     let conf = get_configuration(Some("Cargo.toml")).unwrap();
@@ -464,7 +461,6 @@ pub fn handle_server_fns_with_context(
 ///     .run()
 ///     .await
 /// }
-/// # }
 /// ```
 ///
 /// ## Provided Context Types
@@ -492,7 +488,7 @@ where
 /// sending down its HTML. The app will become interactive once it has fully loaded.
 ///
 /// This can then be set up at an appropriate route in your application:
-/// ```
+/// ```no_run
 /// use actix_web::{App, HttpServer};
 /// use leptos::prelude::*;
 /// use leptos_router::Method;
@@ -503,7 +499,6 @@ where
 ///     view! { <main>"Hello, world!"</main> }
 /// }
 ///
-/// # if false { // don't actually try to run a server in a doctest...
 /// #[actix_web::main]
 /// async fn main() -> std::io::Result<()> {
 ///     let conf = get_configuration(Some("Cargo.toml")).unwrap();
@@ -526,7 +521,6 @@ where
 ///     .run()
 ///     .await
 /// }
-/// # }
 /// ```
 ///
 /// ## Provided Context Types
@@ -552,7 +546,7 @@ where
 /// `async` resources have loaded.
 ///
 /// This can then be set up at an appropriate route in your application:
-/// ```
+/// ```no_run
 /// use actix_web::{App, HttpServer};
 /// use leptos::prelude::*;
 /// use leptos_router::Method;
@@ -563,7 +557,6 @@ where
 ///     view! { <main>"Hello, world!"</main> }
 /// }
 ///
-/// # if false { // don't actually try to run a server in a doctest...
 /// #[actix_web::main]
 /// async fn main() -> std::io::Result<()> {
 ///     let conf = get_configuration(Some("Cargo.toml")).unwrap();
@@ -583,7 +576,6 @@ where
 ///     .run()
 ///     .await
 /// }
-/// # }
 /// ```
 ///
 /// ## Provided Context Types

integrations/axum/Cargo.toml

@@ -24,14 +24,14 @@ leptos_router = { workspace = true, features = ["ssr"] }
 leptos_integration_utils = { workspace = true }
 once_cell = "1"
 parking_lot = "0.12.3"
-tokio = { version = "1.41", default-features = false }
+tokio = { version = "1.43", default-features = false }
 tower = { version = "0.5.1", features = ["util"] }
 tower-http = "0.6.2"
 tracing = { version = "0.1.41", optional = true }
 
 [dev-dependencies]
 axum = "0.7.9"
-tokio = { version = "1.41", features = ["net", "rt-multi-thread"] }
+tokio = { version = "1.43", features = ["net", "rt-multi-thread"] }
 
 [features]
 wasm = []

integrations/axum/src/lib.rs

@@ -1,5 +1,6 @@
 #![forbid(unsafe_code)]
 #![deny(missing_docs)]
+#![allow(clippy::type_complexity)]
 
 //! Provides functions to easily integrate Leptos with Axum.
 //!
@@ -278,12 +279,11 @@ pub fn generate_request_and_parts(
 ///
 /// This can then be set up at an appropriate route in your application:
 ///
-/// ```
+/// ```no_run
 /// use axum::{handler::Handler, routing::post, Router};
 /// use leptos::prelude::*;
 /// use std::net::SocketAddr;
 ///
-/// # if false { // don't actually try to run a server in a doctest...
 /// #[cfg(feature = "default")]
 /// #[tokio::main]
 /// async fn main() {
@@ -299,7 +299,9 @@ pub fn generate_request_and_parts(
 ///         .await
 ///         .unwrap();
 /// }
-/// # }
+///
+/// # #[cfg(not(feature = "default"))]
+/// # fn main() { }
 /// ```
 /// Leptos provides a generic implementation of `handle_server_fns`. If access to more specific parts of the Request is desired,
 /// you can specify your own server fn handler based on this one and give it it's own route in the server macro.
@@ -442,7 +444,7 @@ pub type PinnedHtmlStream =
 /// to route it using [leptos_router], serving an HTML stream of your application.
 ///
 /// This can then be set up at an appropriate route in your application:
-/// ```
+/// ```no_run
 /// use axum::{handler::Handler, Router};
 /// use leptos::{config::get_configuration, prelude::*};
 /// use std::{env, net::SocketAddr};
@@ -452,7 +454,6 @@ pub type PinnedHtmlStream =
 ///     view! { <main>"Hello, world!"</main> }
 /// }
 ///
-/// # if false { // don't actually try to run a server in a doctest...
 /// #[cfg(feature = "default")]
 /// #[tokio::main]
 /// async fn main() {
@@ -471,7 +472,9 @@ pub type PinnedHtmlStream =
 ///         .await
 ///         .unwrap();
 /// }
-/// # }
+///
+/// # #[cfg(not(feature = "default"))]
+/// # fn main() { }
 /// ```
 ///
 /// ## Provided Context Types
@@ -530,7 +533,7 @@ where
 /// sending down its HTML. The app will become interactive once it has fully loaded.
 ///
 /// This can then be set up at an appropriate route in your application:
-/// ```
+/// ```no_run
 /// use axum::{handler::Handler, Router};
 /// use leptos::{config::get_configuration, prelude::*};
 /// use std::{env, net::SocketAddr};
@@ -540,7 +543,6 @@ where
 ///     view! { <main>"Hello, world!"</main> }
 /// }
 ///
-/// # if false { // don't actually try to run a server in a doctest...
 /// #[cfg(feature = "default")]
 /// #[tokio::main]
 /// async fn main() {
@@ -559,7 +561,9 @@ where
 ///         .await
 ///         .unwrap();
 /// }
-/// # }
+///
+/// # #[cfg(not(feature = "default"))]
+/// # fn main() { }
 /// ```
 ///
 /// ## Provided Context Types
@@ -937,7 +941,7 @@ fn provide_contexts(
 /// `async` resources have loaded.
 ///
 /// This can then be set up at an appropriate route in your application:
-/// ```
+/// ```no_run
 /// use axum::{handler::Handler, Router};
 /// use leptos::{config::get_configuration, prelude::*};
 /// use std::{env, net::SocketAddr};
@@ -947,7 +951,6 @@ fn provide_contexts(
 ///     view! { <main>"Hello, world!"</main> }
 /// }
 ///
-/// # if false { // don't actually try to run a server in a doctest...
 /// #[cfg(feature = "default")]
 /// #[tokio::main]
 /// async fn main() {
@@ -967,7 +970,9 @@ fn provide_contexts(
 ///         .await
 ///         .unwrap();
 /// }
-/// # }
+///
+/// # #[cfg(not(feature = "default"))]
+/// # fn main() { }
 /// ```
 ///
 /// ## Provided Context Types
@@ -1981,7 +1986,8 @@ where
 /// This is provided as a convenience, but is a fairly simple function. If you need to adapt it,
 /// simply reuse the source code of this function in your own application.
 #[cfg(feature = "default")]
-pub fn file_and_error_handler<S, IV>(
+pub fn file_and_error_handler_with_context<S, IV>(
+    additional_context: impl Fn() + 'static + Clone + Send,
     shell: fn(LeptosOptions) -> IV,
 ) -> impl Fn(
     Uri,
@@ -1997,40 +2003,68 @@ where
     LeptosOptions: FromRef<S>,
 {
     move |uri: Uri, State(state): State<S>, req: Request<Body>| {
-        Box::pin(async move {
-            let options = LeptosOptions::from_ref(&state);
-            let res = get_static_file(uri, &options.site_root, req.headers());
-            let res = res.await.unwrap();
+        Box::pin({
+            let additional_context = additional_context.clone();
+            async move {
+                let options = LeptosOptions::from_ref(&state);
+                let res =
+                    get_static_file(uri, &options.site_root, req.headers());
+                let res = res.await.unwrap();
 
-            if res.status() == StatusCode::OK {
-                res.into_response()
-            } else {
-                let mut res = handle_response_inner(
-                    move || {
-                        provide_context(state.clone());
-                    },
-                    move || shell(options),
-                    req,
-                    |app, chunks| {
-                        Box::pin(async move {
-                            let app = app
-                                .to_html_stream_in_order()
-                                .collect::<String>()
-                                .await;
-                            let chunks = chunks();
-                            Box::pin(once(async move { app }).chain(chunks))
-                                as PinnedStream<String>
-                        })
-                    },
-                )
-                .await;
-                *res.status_mut() = StatusCode::NOT_FOUND;
-                res
+                if res.status() == StatusCode::OK {
+                    res.into_response()
+                } else {
+                    let mut res = handle_response_inner(
+                        move || {
+                            additional_context();
+                            provide_context(state.clone());
+                        },
+                        move || shell(options),
+                        req,
+                        |app, chunks| {
+                            Box::pin(async move {
+                                let app = app
+                                    .to_html_stream_in_order()
+                                    .collect::<String>()
+                                    .await;
+                                let chunks = chunks();
+                                Box::pin(once(async move { app }).chain(chunks))
+                                    as PinnedStream<String>
+                            })
+                        },
+                    )
+                    .await;
+                    *res.status_mut() = StatusCode::NOT_FOUND;
+                    res
+                }
             }
         })
     }
 }
 
+/// A reasonable handler for serving static files (like JS/WASM/CSS) and 404 errors.
+///
+/// This is provided as a convenience, but is a fairly simple function. If you need to adapt it,
+/// simply reuse the source code of this function in your own application.
+#[cfg(feature = "default")]
+pub fn file_and_error_handler<S, IV>(
+    shell: fn(LeptosOptions) -> IV,
+) -> impl Fn(
+    Uri,
+    State<S>,
+    Request<Body>,
+) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'static>>
+       + Clone
+       + Send
+       + 'static
+where
+    IV: IntoView + 'static,
+    S: Send + Sync + Clone + 'static,
+    LeptosOptions: FromRef<S>,
+{
+    file_and_error_handler_with_context(move || (), shell)
+}
+
 #[cfg(feature = "default")]
 async fn get_static_file(
     uri: Uri,

leptos/Cargo.toml

@@ -52,12 +52,11 @@ web-sys = { version = "0.3.72", features = [
   "ShadowRootInit",
   "ShadowRootMode",
 ] }
-wasm-bindgen = "0.2.97"
+wasm-bindgen = { workspace = true }
 serde_qs = "0.13.0"
 slotmap = "1.0"
 futures = "0.3.31"
 send_wrapper = "0.6.0"
-getrandom = { version = "0.2", features = ["js"], optional = true }
 
 [features]
 hydration = [
@@ -66,13 +65,12 @@ hydration = [
   "hydration_context/browser",
   "leptos_dom/hydration",
 ]
-csr = ["leptos_macro/csr", "reactive_graph/effects", "dep:getrandom"]
+csr = ["leptos_macro/csr", "reactive_graph/effects"]
 hydrate = [
   "leptos_macro/hydrate",
   "hydration",
   "tachys/hydrate",
   "reactive_graph/effects",
-  "dep:getrandom",
 ]
 default-tls = ["server_fn/default-tls"]
 rustls = ["server_fn/rustls"]
@@ -84,10 +82,7 @@ ssr = [
   "tachys/ssr",
 ]
 nightly = ["leptos_macro/nightly", "reactive_graph/nightly", "tachys/nightly"]
-rkyv = [
-  "server_fn/rkyv",
-  "leptos_server/rkyv"
-]
+rkyv = ["server_fn/rkyv", "leptos_server/rkyv"]
 tracing = [
   "dep:tracing",
   "reactive_graph/tracing",

leptos/src/callback.rs

@@ -273,7 +273,7 @@ mod tests {
     #[test]
     fn callback_matches_same() {
         let callback1 = Callback::new(|x: i32| x * 2);
-        let callback2 = callback1.clone();
+        let callback2 = callback1;
         assert!(callback1.matches(&callback2));
     }
 
@@ -287,7 +287,7 @@ mod tests {
     #[test]
     fn unsync_callback_matches_same() {
         let callback1 = UnsyncCallback::new(|x: i32| x * 2);
-        let callback2 = callback1.clone();
+        let callback2 = callback1;
         assert!(callback1.matches(&callback2));
     }
 

leptos/src/suspense_component.rs

@@ -303,11 +303,13 @@ where
         let eff = reactive_graph::effect::Effect::new_isomorphic({
             move |_| {
                 tasks.track();
-                if tasks.read().is_empty() {
-                    if let Some(tx) = tasks_tx.take() {
-                        // If the receiver has dropped, it means the ScopedFuture has already
-                        // dropped, so it doesn't matter if we manage to send this.
-                        _ = tx.send(());
+                if let Some(tasks) = tasks.try_read() {
+                    if tasks.is_empty() {
+                        if let Some(tx) = tasks_tx.take() {
+                            // If the receiver has dropped, it means the ScopedFuture has already
+                            // dropped, so it doesn't matter if we manage to send this.
+                            _ = tx.send(());
+                        }
                     }
                 }
             }

leptos_config/Cargo.toml

@@ -10,7 +10,7 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-config = { version = "0.14.1", default-features = false, features = [
+config = { version = "0.15.8", default-features = false, features = [
   "toml",
   "convert-case",
 ] }
@@ -20,7 +20,7 @@ thiserror = "2.0"
 typed-builder = "0.20.0"
 
 [dev-dependencies]
-tokio = { version = "1.41", features = ["rt", "macros"] }
+tokio = { version = "1.43", features = ["rt", "macros"] }
 tempfile = "3.14"
 temp-env = { version = "0.3.6", features = ["async_closure"] }
 
@@ -28,4 +28,4 @@ temp-env = { version = "0.3.6", features = ["async_closure"] }
 rustdoc-args = ["--generate-link-to-definition"]
 
 [lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(leptos_debuginfo)'] }
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(leptos_debuginfo)'] }

leptos_dom/Cargo.toml

@@ -15,7 +15,7 @@ or_poisoned = { workspace = true }
 js-sys = "0.3.74"
 send_wrapper = "0.6.0"
 tracing = { version = "0.1.41", optional = true }
-wasm-bindgen = "0.2.97"
+wasm-bindgen = { workspace = true }
 serde_json = { version = "1.0", optional = true }
 serde = { version = "1.0", optional = true }
 
@@ -39,4 +39,4 @@ rustdoc-args = ["--generate-link-to-definition"]
 denylist = ["tracing"]
 
 [lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(leptos_debuginfo)'] }
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(leptos_debuginfo)'] }

leptos_macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_macro"
-version = "0.7.5"
+version = { workspace = true }
 authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"
@@ -16,7 +16,7 @@ proc-macro = true
 attribute-derive = { version = "0.10.3", features = ["syn-full"] }
 cfg-if = "1.0"
 html-escape = "0.2.13"
-itertools = "0.13.0"
+itertools = { workspace = true }
 prettyplease = "0.2.25"
 proc-macro-error2 = { version = "2.0", default-features = false }
 proc-macro2 = "1.0"
@@ -25,7 +25,7 @@ syn = { version = "2.0", features = ["full"] }
 rstml = "0.12.0"
 leptos_hot_reload = { workspace = true }
 server_fn_macro = { workspace = true }
-convert_case = "0.6.0"
+convert_case = "0.7"
 uuid = { version = "1.11", features = ["v4"] }
 tracing = { version = "0.1.41", optional = true }
 
@@ -34,7 +34,7 @@ log = "0.4.22"
 typed-builder = "0.20.0"
 trybuild = "1.0"
 leptos = { path = "../leptos" }
-leptos_router = { path = "../router", features= ["ssr"] }
+leptos_router = { path = "../router", features = ["ssr"] }
 server_fn = { path = "../server_fn", features = ["cbor"] }
 insta = "1.41"
 serde = "1.0"
@@ -55,30 +55,30 @@ generic = ["server_fn_macro/generic"]
 [package.metadata.cargo-all-features]
 denylist = ["nightly", "tracing", "trace-component-props"]
 skip_feature_sets = [
-	[
-		"csr",
-		"hydrate",
-	],
-	[
-		"hydrate",
-		"csr",
-	],
-	[
-		"hydrate",
-		"ssr",
-	],
-	[
-		"actix",
-		"axum",
-	],
-	[
-		"actix",
-		"generic",
-	],
-	[
-		"generic",
-		"axum",
-	],
+  [
+    "csr",
+    "hydrate",
+  ],
+  [
+    "hydrate",
+    "csr",
+  ],
+  [
+    "hydrate",
+    "ssr",
+  ],
+  [
+    "actix",
+    "axum",
+  ],
+  [
+    "actix",
+    "generic",
+  ],
+  [
+    "generic",
+    "axum",
+  ],
 ]
 
 [package.metadata.docs.rs]
@@ -86,6 +86,6 @@ rustdoc-args = ["--generate-link-to-definition"]
 
 [lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = [
-	'cfg(leptos_debuginfo)',
-	'cfg(erase_components)',
+  'cfg(leptos_debuginfo)',
+  'cfg(erase_components)',
 ] }

leptos_macro/Makefile.toml

@@ -11,13 +11,13 @@ dependencies = [
 [tasks.test-leptos_macro-example]
 description = "Tests the leptos_macro/example to check if macro handles doc comments correctly"
 command = "cargo"
-args = ["+nightly-2024-08-01", "test", "--doc"]
+args = ["+nightly-2025-03-05", "test", "--doc"]
 cwd = "example"
 install_crate = false
 
 [tasks.doc-leptos_macro-example]
 description = "Docs the leptos_macro/example to check if macro handles doc comments correctly"
 command = "cargo"
-args = ["+nightly-2024-08-01", "doc"]
+args = ["+nightly-2025-03-05", "doc"]
 cwd = "example"
 install_crate = false

leptos_macro/src/component.rs

@@ -144,8 +144,6 @@ impl ToTokens for Model {
         let (impl_generics, generics, where_clause) =
             body.sig.generics.split_for_impl();
 
-        let lifetimes = body.sig.generics.lifetimes();
-
         let props_name = format_ident!("{name}Props");
         let props_builder_name = format_ident!("{name}PropsBuilder");
         let props_serialized_name = format_ident!("{name}PropsSerialized");
@@ -570,7 +568,7 @@ impl ToTokens for Model {
             #tracing_instrument_attr
             #vis fn #name #impl_generics (
                 #props_arg
-            ) #ret #(+ #lifetimes)*
+            ) #ret
             #where_clause
             {
                 #body

leptos_macro/src/lib.rs

@@ -677,17 +677,21 @@ fn component_macro(
             #[allow(non_snake_case, dead_code, clippy::too_many_arguments, clippy::needless_lifetimes)]
             #unexpanded
         }
-    } else if let Ok(mut dummy) = dummy {
-        dummy.sig.ident = unmodified_fn_name_from_fn_name(&dummy.sig.ident);
-        quote! {
-            #[doc(hidden)]
-            #[allow(non_snake_case, dead_code, clippy::too_many_arguments, clippy::needless_lifetimes)]
-            #dummy
-        }
     } else {
-        quote! {}
-    }
-    .into()
+        match dummy {
+            Ok(mut dummy) => {
+                dummy.sig.ident = unmodified_fn_name_from_fn_name(&dummy.sig.ident);
+                quote! {
+                    #[doc(hidden)]
+                    #[allow(non_snake_case, dead_code, clippy::too_many_arguments, clippy::needless_lifetimes)]
+                    #dummy
+                }
+            }
+            Err(e) => {
+                proc_macro_error2::abort!(e.span(), e);
+            }
+        }
+    }.into()
 }
 
 /// Annotates a struct so that it can be used with your Component as a `slot`.

leptos_macro/src/view/mod.rs

@@ -154,7 +154,12 @@ fn is_inert_element(orig_node: &Node<impl CustomNode>) -> bool {
                                         Some(value) => {
                                             matches!(&value.value, KVAttributeValue::Expr(expr) if {
                                                 if let Expr::Lit(lit) = expr {
-                                                    matches!(&lit.lit, Lit::Str(_))
+                                                    let key = attr.key.to_string();
+                                                    if key.starts_with("style:") || key.starts_with("prop:") || key.starts_with("on:") || key.starts_with("use:") || key.starts_with("bind") {
+                                                        false
+                                                    } else {
+                                                        matches!(&lit.lit, Lit::Str(_))
+                                                    }
                                                 } else {
                                                     false
                                                 }
@@ -1152,8 +1157,14 @@ pub(crate) fn two_way_binding_to_tokens(
     let ident =
         format_ident!("{}", name.to_case(UpperCamel), span = node.key.span());
 
-    quote! {
-        .bind(::leptos::attr::#ident, #value)
+    if name == "group" {
+        quote! {
+            .bind(leptos::tachys::reactive_graph::bind::#ident, #value)
+        }
+    } else {
+        quote! {
+            .bind(::leptos::attr::#ident, #value)
+        }
     }
 }
 
@@ -1174,8 +1185,7 @@ pub(crate) fn event_type_and_handler(
 ) -> (TokenStream, TokenStream, TokenStream) {
     let handler = attribute_value(node, false);
 
-    let (event_type, is_custom, is_force_undelegated, is_targeted) =
-        parse_event_name(name);
+    let (event_type, is_custom, options) = parse_event_name(name);
 
     let event_name_ident = match &node.key {
         NodeName::Punctuated(parts) => {
@@ -1193,11 +1203,17 @@ pub(crate) fn event_type_and_handler(
         }
         _ => unreachable!(),
     };
+    let capture_ident = match &node.key {
+        NodeName::Punctuated(parts) => {
+            parts.iter().find(|part| part.to_string() == "capture")
+        }
+        _ => unreachable!(),
+    };
     let on = match &node.key {
         NodeName::Punctuated(parts) => &parts[0],
         _ => unreachable!(),
     };
-    let on = if is_targeted {
+    let on = if options.targeted {
         Ident::new("on_target", on.span()).to_token_stream()
     } else {
         on.to_token_stream()
@@ -1210,15 +1226,29 @@ pub(crate) fn event_type_and_handler(
         event_type
     };
 
-    let event_type = if is_force_undelegated {
+    let event_type = quote! {
+        ::leptos::tachys::html::event::#event_type
+    };
+    let event_type = if options.captured {
+        let capture = if let Some(capture) = capture_ident {
+            quote! { #capture }
+        } else {
+            quote! { capture }
+        };
+        quote! { ::leptos::tachys::html::event::#capture(#event_type) }
+    } else {
+        event_type
+    };
+
+    let event_type = if options.undelegated {
         let undelegated = if let Some(undelegated) = undelegated_ident {
             quote! { #undelegated }
         } else {
             quote! { undelegated }
         };
-        quote! { ::leptos::tachys::html::event::#undelegated(::leptos::tachys::html::event::#event_type) }
+        quote! { ::leptos::tachys::html::event::#undelegated(#event_type) }
     } else {
-        quote! { ::leptos::tachys::html::event::#event_type }
+        event_type
     };
 
     (on, event_type, handler)
@@ -1424,13 +1454,22 @@ fn is_ambiguous_element(tag: &str) -> bool {
     tag == "a" || tag == "script" || tag == "title"
 }
 
-fn parse_event(event_name: &str) -> (String, bool, bool) {
-    let is_undelegated = event_name.contains(":undelegated");
-    let is_targeted = event_name.contains(":target");
+fn parse_event(event_name: &str) -> (String, EventNameOptions) {
+    let undelegated = event_name.contains(":undelegated");
+    let targeted = event_name.contains(":target");
+    let captured = event_name.contains(":capture");
     let event_name = event_name
         .replace(":undelegated", "")
-        .replace(":target", "");
-    (event_name, is_undelegated, is_targeted)
+        .replace(":target", "")
+        .replace(":capture", "");
+    (
+        event_name,
+        EventNameOptions {
+            undelegated,
+            targeted,
+            captured,
+        },
+    )
 }
 
 /// Escapes Rust keywords that are also HTML attribute names
@@ -1622,8 +1661,17 @@ const TYPED_EVENTS: [&str; 126] = [
 
 const CUSTOM_EVENT: &str = "Custom";
 
-pub(crate) fn parse_event_name(name: &str) -> (TokenStream, bool, bool, bool) {
-    let (name, is_force_undelegated, is_targeted) = parse_event(name);
+#[derive(Debug)]
+pub(crate) struct EventNameOptions {
+    undelegated: bool,
+    targeted: bool,
+    captured: bool,
+}
+
+pub(crate) fn parse_event_name(
+    name: &str,
+) -> (TokenStream, bool, EventNameOptions) {
+    let (name, options) = parse_event(name);
 
     let (event_type, is_custom) = TYPED_EVENTS
         .binary_search(&name.as_str())
@@ -1639,7 +1687,7 @@ pub(crate) fn parse_event_name(name: &str) -> (TokenStream, bool, bool, bool) {
     } else {
         event_type
     };
-    (event_type, is_custom, is_force_undelegated, is_targeted)
+    (event_type, is_custom, options)
 }
 
 fn convert_to_snake_case(name: String) -> String {

leptos_macro/tests/component.rs

@@ -104,3 +104,18 @@ fn component_nostrip() {
         />
     };
 }
+
+#[component]
+fn WithLifetime<'a>(data: &'a str) -> impl IntoView {
+    _ = data;
+    "static lifetime"
+}
+
+#[test]
+fn returns_static_lifetime() {
+    #[allow(unused)]
+    fn can_return_impl_intoview_from_body() -> impl IntoView {
+        let val = String::from("non_static_lifetime");
+        WithLifetime(WithLifetimeProps::builder().data(&val).build())
+    }
+}

leptos_server/Cargo.toml

@@ -26,8 +26,8 @@ send_wrapper = "0.6"
 # serialization formats
 serde = { version = "1.0" }
 js-sys = { version = "0.3.74", optional = true }
-wasm-bindgen = { version = "0.2.97", optional = true }
-serde_json = { version = "1.0" }
+wasm-bindgen = { version = "0.2.100", optional = true }
+serde_json = { workspace = true }
 
 [features]
 ssr = []
@@ -46,4 +46,4 @@ denylist = ["tracing"]
 rustdoc-args = ["--generate-link-to-definition"]
 
 [lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(leptos_debuginfo)'] }
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(leptos_debuginfo)'] }

leptos_server/src/local_resource.rs

@@ -12,7 +12,9 @@ use reactive_graph::{
         guards::{AsyncPlain, ReadGuard},
         ArcRwSignal, RwSignal,
     },
-    traits::{DefinedAt, IsDisposed, ReadUntracked, Track, Update, Write},
+    traits::{
+        DefinedAt, IsDisposed, ReadUntracked, Track, Update, With, Write,
+    },
 };
 use send_wrapper::SendWrapper;
 use std::{
@@ -91,6 +93,34 @@ impl<T> ArcLocalResource<T> {
     pub fn refetch(&self) {
         *self.refetch.write() += 1;
     }
+
+    /// Synchronously, reactively reads the current value of the resource and applies the function
+    /// `f` to its value if it is `Some(_)`.
+    #[track_caller]
+    pub fn map<U>(&self, f: impl FnOnce(&SendWrapper<T>) -> U) -> Option<U>
+    where
+        T: 'static,
+    {
+        self.data.try_with(|n| n.as_ref().map(f))?
+    }
+}
+
+impl<T, E> ArcLocalResource<Result<T, E>>
+where
+    T: 'static,
+    E: Clone + 'static,
+{
+    /// Applies the given function when a resource that returns `Result<T, E>`
+    /// has resolved and loaded an `Ok(_)`, rather than requiring nested `.map()`
+    /// calls over the `Option<Result<_, _>>` returned by the resource.
+    ///
+    /// This is useful when used with features like server functions, in conjunction
+    /// with `<ErrorBoundary/>` and `<Suspense/>`, when these other components are
+    /// left to handle the `None` and `Err(_)` states.
+    #[track_caller]
+    pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>> {
+        self.map(|data| data.as_ref().map(f).map_err(|e| e.clone()))
+    }
 }
 
 impl<T> IntoFuture for ArcLocalResource<T>
@@ -142,12 +172,6 @@ where
     fn try_read_untracked(&self) -> Option<Self::Value> {
         if let Some(mut notifier) = use_context::<LocalResourceNotifier>() {
             notifier.notify();
-        } else if cfg!(feature = "ssr") {
-            panic!(
-                "Reading from a LocalResource outside Suspense in `ssr` mode \
-                 will cause the response to hang, because LocalResources are \
-                 always pending on the server."
-            );
         }
         self.data.try_read_untracked()
     }
@@ -334,12 +358,6 @@ where
     fn try_read_untracked(&self) -> Option<Self::Value> {
         if let Some(mut notifier) = use_context::<LocalResourceNotifier>() {
             notifier.notify();
-        } else if cfg!(feature = "ssr") {
-            panic!(
-                "Reading from a LocalResource outside Suspense in `ssr` mode \
-                 will cause the response to hang, because LocalResources are \
-                 always pending on the server."
-            );
         }
         self.data.try_read_untracked()
     }

leptos_server/src/once_resource.rs

@@ -168,6 +168,41 @@ where
 
         data
     }
+
+    /// Synchronously, reactively reads the current value of the resource and applies the function
+    /// `f` to its value if it is `Some(_)`.
+    #[track_caller]
+    pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>
+    where
+        T: Send + Sync + 'static,
+    {
+        self.try_with(|n| n.as_ref().map(f))?
+    }
+}
+
+impl<T, E, Ser> ArcOnceResource<Result<T, E>, Ser>
+where
+    Ser: Encoder<Result<T, E>> + Decoder<Result<T, E>>,
+    <Ser as Encoder<Result<T, E>>>::Error: Debug,
+    <Ser as Decoder<Result<T, E>>>::Error: Debug,
+    <<Ser as Decoder<Result<T, E>>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <Ser as Encoder<Result<T, E>>>::Encoded: IntoEncodedString,
+    <Ser as Decoder<Result<T, E>>>::Encoded: FromEncodedStr,
+    T: Send + Sync + 'static,
+    E: Send + Sync + Clone + 'static,
+{
+    /// Applies the given function when a resource that returns `Result<T, E>`
+    /// has resolved and loaded an `Ok(_)`, rather than requiring nested `.map()`
+    /// calls over the `Option<Result<_, _>>` returned by the resource.
+    ///
+    /// This is useful when used with features like server functions, in conjunction
+    /// with `<ErrorBoundary/>` and `<Suspense/>`, when these other components are
+    /// left to handle the `None` and `Err(_)` states.
+    #[track_caller]
+    pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>> {
+        self.map(|data| data.as_ref().map(f).map_err(|e| e.clone()))
+    }
 }
 
 impl<T, Ser> ArcOnceResource<T, Ser> {
@@ -534,6 +569,37 @@ where
             defined_at,
         }
     }
+
+    /// Synchronously, reactively reads the current value of the resource and applies the function
+    /// `f` to its value if it is `Some(_)`.
+    pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U> {
+        self.try_with(|n| n.as_ref().map(|n| Some(f(n))))?.flatten()
+    }
+}
+
+impl<T, E, Ser> OnceResource<Result<T, E>, Ser>
+where
+    Ser: Encoder<Result<T, E>> + Decoder<Result<T, E>>,
+    <Ser as Encoder<Result<T, E>>>::Error: Debug,
+    <Ser as Decoder<Result<T, E>>>::Error: Debug,
+    <<Ser as Decoder<Result<T, E>>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <Ser as Encoder<Result<T, E>>>::Encoded: IntoEncodedString,
+    <Ser as Decoder<Result<T, E>>>::Encoded: FromEncodedStr,
+    T: Send + Sync + 'static,
+    E: Send + Sync + Clone + 'static,
+{
+    /// Applies the given function when a resource that returns `Result<T, E>`
+    /// has resolved and loaded an `Ok(_)`, rather than requiring nested `.map()`
+    /// calls over the `Option<Result<_, _>>` returned by the resource.
+    ///
+    /// This is useful when used with features like server functions, in conjunction
+    /// with `<ErrorBoundary/>` and `<Suspense/>`, when these other components are
+    /// left to handle the `None` and `Err(_)` states.
+    #[track_caller]
+    pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>> {
+        self.map(|data| data.as_ref().map(f).map_err(|e| e.clone()))
+    }
 }
 
 impl<T, Ser> OnceResource<T, Ser>

leptos_server/src/shared.rs

@@ -215,16 +215,11 @@ where
                                 None
                             }
                             Ok(encoded) => {
-                                match Ser::decode(encoded.borrow()) {
-                                    #[allow(unused_variables)]
-                                    // used in tracing
-                                    Err(e) => {
-                                        #[cfg(feature = "tracing")]
-                                        tracing::error!("{e:?}");
-                                        None
-                                    }
-                                    Ok(value) => Some(value),
-                                }
+                                let decoded = Ser::decode(encoded.borrow());
+                                #[cfg(feature = "tracing")]
+                                let decoded = decoded
+                                    .inspect_err(|e| tracing::error!("{e:?}"));
+                                decoded.ok()
                             }
                         }
                     }

meta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_meta"
-version = "0.7.5"
+version = "0.7.7"
 authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"
@@ -15,7 +15,7 @@ or_poisoned = { workspace = true }
 indexmap = "2.6"
 send_wrapper = "0.6.0"
 tracing = { version = "0.1.41", optional = true }
-wasm-bindgen = "0.2.97"
+wasm-bindgen = { workspace = true }
 futures = "0.3.31"
 
 [dependencies.web-sys]

meta/src/lib.rs

@@ -323,37 +323,13 @@ pub(crate) fn register<E, At, Ch>(
 where
     HtmlElement<E, At, Ch>: RenderHtml,
 {
-    #[allow(unused_mut)] // used for `ssr`
-    let mut el = Some(el);
-
-    #[cfg(feature = "ssr")]
-    if let Some(cx) = use_context::<ServerMetaContext>() {
-        let mut buf = String::new();
-        el.take().unwrap().to_html_with_buf(
-            &mut buf,
-            &mut Position::NextChild,
-            false,
-            false,
-        );
-        _ = cx.elements.send(buf); // fails only if the receiver is already dropped
-    } else {
-        let msg = "tried to use a leptos_meta component without \
-                   `ServerMetaContext` provided";
-
-        #[cfg(feature = "tracing")]
-        tracing::warn!("{}", msg);
-
-        #[cfg(not(feature = "tracing"))]
-        eprintln!("{}", msg);
-    }
-
     RegisteredMetaTag { el }
 }
 
 struct RegisteredMetaTag<E, At, Ch> {
     // this is `None` if we've already taken it out to render to HTML on the server
     // we don't render it in place in RenderHtml, so it's fine
-    el: Option<HtmlElement<E, At, Ch>>,
+    el: HtmlElement<E, At, Ch>,
 }
 
 struct RegisteredMetaTagState<E, At, Ch>
@@ -391,12 +367,12 @@ where
     type State = RegisteredMetaTagState<E, At, Ch>;
 
     fn build(self) -> Self::State {
-        let state = self.el.unwrap().build();
+        let state = self.el.build();
         RegisteredMetaTagState { state }
     }
 
     fn rebuild(self, state: &mut Self::State) {
-        self.el.unwrap().rebuild(&mut state.state);
+        self.el.rebuild(&mut state.state);
     }
 }
 
@@ -417,7 +393,7 @@ where
         Self::Output<NewAttr>: RenderHtml,
     {
         RegisteredMetaTag {
-            el: self.el.map(|inner| inner.add_any_attr(attr)),
+            el: self.el.add_any_attr(attr),
         }
     }
 }
@@ -449,6 +425,26 @@ where
     ) {
         // meta tags are rendered into the buffer stored into the context
         // the value has already been taken out, when we're on the server
+        #[cfg(feature = "ssr")]
+        if let Some(cx) = use_context::<ServerMetaContext>() {
+            let mut buf = String::new();
+            self.el.to_html_with_buf(
+                &mut buf,
+                &mut Position::NextChild,
+                false,
+                false,
+            );
+            _ = cx.elements.send(buf); // fails only if the receiver is already dropped
+        } else {
+            let msg = "tried to use a leptos_meta component without \
+                       `ServerMetaContext` provided";
+
+            #[cfg(feature = "tracing")]
+            tracing::warn!("{}", msg);
+
+            #[cfg(not(feature = "tracing"))]
+            eprintln!("{}", msg);
+        }
     }
 
     fn hydrate<const FROM_SERVER: bool>(
@@ -462,7 +458,7 @@ where
                  MetaContext provided",
             )
             .cursor;
-        let state = self.el.unwrap().hydrate::<FROM_SERVER>(
+        let state = self.el.hydrate::<FROM_SERVER>(
             &cursor,
             &PositionState::new(Position::NextChild),
         );

oco/Cargo.toml

@@ -13,4 +13,4 @@ serde = "1.0"
 thiserror = "2.0"
 
 [dev-dependencies]
-serde_json = "1.0"
+serde_json = { workspace = true }

or_poisoned/src/lib.rs

@@ -35,7 +35,7 @@ pub trait OrPoisoned {
     fn or_poisoned(self) -> Self::Inner;
 }
 
-impl<'a, T> OrPoisoned
+impl<'a, T: ?Sized> OrPoisoned
     for Result<RwLockReadGuard<'a, T>, PoisonError<RwLockReadGuard<'a, T>>>
 {
     type Inner = RwLockReadGuard<'a, T>;
@@ -45,7 +45,7 @@ impl<'a, T> OrPoisoned
     }
 }
 
-impl<'a, T> OrPoisoned
+impl<'a, T: ?Sized> OrPoisoned
     for Result<RwLockWriteGuard<'a, T>, PoisonError<RwLockWriteGuard<'a, T>>>
 {
     type Inner = RwLockWriteGuard<'a, T>;
@@ -55,7 +55,7 @@ impl<'a, T> OrPoisoned
     }
 }
 
-impl<'a, T> OrPoisoned for LockResult<MutexGuard<'a, T>> {
+impl<'a, T: ?Sized> OrPoisoned for LockResult<MutexGuard<'a, T>> {
     type Inner = MutexGuard<'a, T>;
 
     fn or_poisoned(self) -> Self::Inner {

projects/bevy3d_ui/Cargo.toml

@@ -8,19 +8,19 @@ codegen-units = 1
 lto = true
 
 [dependencies]
-leptos = { version = "0.6.13", features = ["csr"] }
-leptos_meta = { version = "0.6.13", features = ["csr"] }
-leptos_router = { version = "0.6.13", features = ["csr"] }
+leptos = { version = "0.7.7", features = ["csr"] }
+leptos_meta = { version = "0.7.7" }
+leptos_router = { version = "0.7.7" }
 console_log = "1.0"
 log = "0.4.22"
 console_error_panic_hook = "0.1.7"
-bevy = "0.14.1"
+bevy = "0.15.2"
 crossbeam-channel = "0.5.13"
 
 [dev-dependencies]
-wasm-bindgen = "0.2.92"
-wasm-bindgen-test = "0.3.42"
-web-sys = "0.3.69"
+wasm-bindgen = "0.2.100"
+wasm-bindgen-test = "0.3.50"
+web-sys = "0.3.77"
 
 [workspace]
 # The empty workspace here is to keep rust-analyzer satisfied

projects/bevy3d_ui/src/demos/bevydemo1/eventqueue/plugin.rs

@@ -17,7 +17,7 @@ impl DuplexEventsPlugin {
         let (bevy_sender, client_receiver) = crossbeam_channel::bounded(50);
         // For sending message from the client to bevy
         let (client_sender, bevy_receiver) = crossbeam_channel::bounded(50);
-        let instance = DuplexEventsPlugin {
+        DuplexEventsPlugin {
             client_processor: EventProcessor {
                 sender: client_sender,
                 receiver: client_receiver,
@@ -26,8 +26,7 @@ impl DuplexEventsPlugin {
                 sender: bevy_sender,
                 receiver: bevy_receiver,
             },
-        };
-        instance
+        }
     }
 
     /// Get the client event processor

projects/bevy3d_ui/src/demos/bevydemo1/scene.rs

@@ -23,14 +23,13 @@ impl Scene {
     /// Create a new instance
     pub fn new(canvas_id: String) -> Scene {
         let plugin = DuplexEventsPlugin::new();
-        let instance = Scene {
+        Scene {
             is_setup: false,
-            canvas_id: canvas_id,
+            canvas_id,
             evt_plugin: plugin.clone(),
             shared_state: SharedState::new(),
             processor: plugin.get_processor(),
-        };
-        instance
+        }
     }
 
     /// Get the shared state
@@ -47,7 +46,7 @@ impl Scene {
 
     /// Setup and attach the bevy instance to the html canvas element
     pub fn setup(&mut self) {
-        if self.is_setup == true {
+        if self.is_setup {
             return;
         };
         App::new()
@@ -76,40 +75,37 @@ fn setup_scene(
 ) {
     let name = resource.0.lock().unwrap().name.clone();
     // circular base
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Circle::new(4.0)),
-        material: materials.add(Color::WHITE),
-        transform: Transform::from_rotation(Quat::from_rotation_x(
+    commands.spawn((
+        Mesh3d(meshes.add(Circle::new(4.0))),
+        MeshMaterial3d(materials.add(Color::WHITE)),
+        Transform::from_rotation(Quat::from_rotation_x(
             -std::f32::consts::FRAC_PI_2,
         )),
-        ..default()
-    });
+    ));
+
     // cube
     commands.spawn((
-        PbrBundle {
-            mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
-            material: materials.add(Color::rgb_u8(124, 144, 255)),
-            transform: Transform::from_xyz(0.0, 0.5, 0.0),
-            ..default()
-        },
+        Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
+        MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
+        Transform::from_xyz(0.0, 0.5, 0.0),
         Cube,
     ));
+
     // light
-    commands.spawn(PointLightBundle {
-        point_light: PointLight {
+    commands.spawn((
+        PointLight {
             shadows_enabled: true,
             ..default()
         },
-        transform: Transform::from_xyz(4.0, 8.0, 4.0),
-        ..default()
-    });
+        Transform::from_xyz(4.0, 8.0, 4.0),
+    ));
+
     // camera
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(-2.5, 4.5, 9.0)
-            .looking_at(Vec3::ZERO, Vec3::Y),
-        ..default()
-    });
-    commands.spawn(TextBundle::from_section(name, TextStyle::default()));
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+    commands.spawn((Text::new(name), TextFont::default()));
 }
 
 /// Move the Cube on event

projects/bevy3d_ui/src/main.rs

@@ -1,6 +1,6 @@
 mod demos;
 mod routes;
-use leptos::*;
+use leptos::prelude::*;
 use routes::RootPage;
 
 pub fn main() {

projects/bevy3d_ui/src/routes/demo1.rs

@@ -2,7 +2,7 @@ use crate::demos::bevydemo1::eventqueue::events::{
     ClientInEvents, CounterEvtData,
 };
 use crate::demos::bevydemo1::scene::Scene;
-use leptos::*;
+use leptos::prelude::*;
 
 /// 3d view component
 #[component]
@@ -10,18 +10,18 @@ pub fn Demo1() -> impl IntoView {
     // Setup a Counter
     let initial_value: i32 = 0;
     let step: i32 = 1;
-    let (value, set_value) = create_signal(initial_value);
+    let (value, set_value) = signal(initial_value);
 
     // Setup a bevy 3d scene
     let scene = Scene::new("#bevy".to_string());
     let sender = scene.get_processor().sender;
-    let (sender_sig, _set_sender_sig) = create_signal(sender);
-    let (scene_sig, _set_scene_sig) = create_signal(scene);
+    let (sender_sig, _set_sender_sig) = signal(sender);
+    let (scene_sig, _set_scene_sig) = signal(scene);
 
     // We need to add the 3D view onto the canvas post render.
-    create_effect(move |_| {
+    Effect::new(move |_| {
         request_animation_frame(move || {
-            scene_sig.get().setup();
+            scene_sig.get_untracked().setup();
         });
     });
 

projects/bevy3d_ui/src/routes/mod.rs

@@ -1,9 +1,11 @@
 pub mod demo1;
 use demo1::Demo1;
-use leptos::*;
-use leptos_meta::{provide_meta_context, Meta, Stylesheet, Title};
-use leptos_router::*;
-
+use leptos::prelude::*;
+use leptos_meta::Meta;
+use leptos_meta::Title;
+use leptos_meta::{provide_meta_context, MetaTags, Stylesheet};
+use leptos_router::components::*;
+use leptos_router::StaticSegment;
 #[component]
 pub fn RootPage() -> impl IntoView {
     provide_meta_context();
@@ -13,11 +15,12 @@ pub fn RootPage() -> impl IntoView {
         <Meta name="description" content="Leptonic CSR template"/>
         <Meta name="viewport" content="width=device-width, initial-scale=1.0"/>
         <Meta name="theme-color" content="#e66956"/>
-        <Stylesheet href="https://fonts.googleapis.com/css?family=Roboto&display=swap"/>
         <Title text="Leptos Bevy3D Example"/>
+        <Stylesheet href="https://fonts.googleapis.com/css?family=Roboto&display=swap"/>
+        <MetaTags/>
         <Router>
-            <Routes>
-                <Route path="" view=|| view! { <Demo1/> }/>
+            <Routes fallback=move || "Not found.">
+                <Route path=StaticSegment("") view=Demo1 />
             </Routes>
         </Router>
     }

reactive_graph/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reactive_graph"
-version = "0.1.5"
+version = "0.1.7"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"
@@ -28,7 +28,7 @@ send_wrapper = { version = "0.6.0", features = ["futures"] }
 web-sys = { version = "0.3.72", features = ["console"] }
 
 [dev-dependencies]
-tokio = { version = "1.41", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1.43", features = ["rt-multi-thread", "macros"] }
 tokio-test = { version = "0.4.4" }
 any_spawner = { workspace = true, features = ["futures-executor", "tokio"] }
 

reactive_graph/src/actions/action.rs

@@ -939,7 +939,8 @@ where
     #[track_caller]
     pub fn dispatch(&self, input: I) -> ActionAbortHandle {
         self.inner
-            .try_with_value(|inner| inner.dispatch(input))
+            .try_get_value()
+            .map(|inner| inner.dispatch(input))
             .unwrap_or_else(unwrap_signal!(self))
     }
 }
@@ -954,7 +955,8 @@ where
     #[track_caller]
     pub fn dispatch_local(&self, input: I) -> ActionAbortHandle {
         self.inner
-            .try_with_value(|inner| inner.dispatch_local(input))
+            .try_get_value()
+            .map(|inner| inner.dispatch_local(input))
             .unwrap_or_else(unwrap_signal!(self))
     }
 }

reactive_graph/src/computed/async_derived/arc_async_derived.rs

@@ -324,7 +324,7 @@ macro_rules! spawn_derived {
                     }
 
                     while rx.next().await.is_some() {
-                        let update_if_necessary = if $should_track {
+                        let update_if_necessary = !owner.paused() && if $should_track {
                             any_subscriber
                                 .with_observer(|| any_subscriber.update_if_necessary())
                         } else {

reactive_graph/src/effect.rs

@@ -3,11 +3,13 @@
 #[allow(clippy::module_inception)]
 mod effect;
 mod effect_function;
+mod immediate;
 mod inner;
 mod render_effect;
 
 pub use effect::*;
 pub use effect_function::*;
+pub use immediate::*;
 pub use render_effect::*;
 
 /// Creates a new render effect, which immediately runs `fun`.

reactive_graph/src/effect/effect.rs

@@ -170,9 +170,10 @@ impl Effect<LocalStorage> {
 
                 async move {
                     while rx.next().await.is_some() {
-                        if subscriber
-                            .with_observer(|| subscriber.update_if_necessary())
-                            || first_run
+                        if !owner.paused()
+                            && (subscriber.with_observer(|| {
+                                subscriber.update_if_necessary()
+                            }) || first_run)
                         {
                             first_run = false;
                             subscriber.clear_sources(&subscriber);
@@ -321,9 +322,10 @@ impl Effect<LocalStorage> {
 
                 async move {
                     while rx.next().await.is_some() {
-                        if subscriber
-                            .with_observer(|| subscriber.update_if_necessary())
-                            || first_run
+                        if !owner.paused()
+                            && (subscriber.with_observer(|| {
+                                subscriber.update_if_necessary()
+                            }) || first_run)
                         {
                             subscriber.clear_sources(&subscriber);
 
@@ -372,46 +374,16 @@ impl Effect<SyncStorage> {
     /// This spawns a task that can be run on any thread. For an effect that will be spawned on
     /// the current thread, use [`new`](Effect::new).
     pub fn new_sync<T, M>(
-        mut fun: impl EffectFunction<T, M> + Send + Sync + 'static,
+        fun: impl EffectFunction<T, M> + Send + Sync + 'static,
     ) -> Self
     where
         T: Send + Sync + 'static,
     {
-        let inner = cfg!(feature = "effects").then(|| {
-            let (mut rx, owner, inner) = effect_base();
-            let mut first_run = true;
-            let value = Arc::new(RwLock::new(None::<T>));
+        if !cfg!(feature = "effects") {
+            return Self { inner: None };
+        }
 
-            crate::spawn({
-                let value = Arc::clone(&value);
-                let subscriber = inner.to_any_subscriber();
-
-                async move {
-                    while rx.next().await.is_some() {
-                        if subscriber
-                            .with_observer(|| subscriber.update_if_necessary())
-                            || first_run
-                        {
-                            first_run = false;
-                            subscriber.clear_sources(&subscriber);
-
-                            let old_value =
-                                mem::take(&mut *value.write().or_poisoned());
-                            let new_value = owner.with_cleanup(|| {
-                                subscriber.with_observer(|| {
-                                    run_in_effect_scope(|| fun.run(old_value))
-                                })
-                            });
-                            *value.write().or_poisoned() = Some(new_value);
-                        }
-                    }
-                }
-            });
-
-            ArenaItem::new_with_storage(Some(inner))
-        });
-
-        Self { inner }
+        Self::new_isomorphic(fun)
     }
 
     /// Creates a new effect, which runs once on the next “tick”, and then runs again when reactive values
@@ -434,9 +406,10 @@ impl Effect<SyncStorage> {
 
             async move {
                 while rx.next().await.is_some() {
-                    if subscriber
-                        .with_observer(|| subscriber.update_if_necessary())
-                        || first_run
+                    if !owner.paused()
+                        && (subscriber
+                            .with_observer(|| subscriber.update_if_necessary())
+                            || first_run)
                     {
                         first_run = false;
                         subscriber.clear_sources(&subscriber);
@@ -487,9 +460,10 @@ impl Effect<SyncStorage> {
 
                 async move {
                     while rx.next().await.is_some() {
-                        if subscriber
-                            .with_observer(|| subscriber.update_if_necessary())
-                            || first_run
+                        if !owner.paused()
+                            && (subscriber.with_observer(|| {
+                                subscriber.update_if_necessary()
+                            }) || first_run)
                         {
                             subscriber.clear_sources(&subscriber);
 

reactive_graph/src/effect/immediate.rs

@@ -0,0 +1,379 @@
+use crate::{
+    graph::{AnySubscriber, ReactiveNode, ToAnySubscriber},
+    owner::on_cleanup,
+    traits::{DefinedAt, Dispose},
+};
+use or_poisoned::OrPoisoned;
+use std::{
+    panic::Location,
+    sync::{Arc, Mutex, RwLock},
+};
+
+/// Effects run a certain chunk of code whenever the signals they depend on change.
+///
+/// The effect runs on creation and again as soon as any tracked signal changes.
+///
+/// NOTE: you probably want use [`Effect`](super::Effect) instead.
+/// This is for the few cases where it's important to execute effects immediately and in order.
+///
+/// [ImmediateEffect]s stop running when dropped.
+///
+/// NOTE: since effects are executed immediately, they might recurse.
+/// Under recursion or parallelism only the last run to start is tracked.
+///
+/// ## Example
+///
+/// ```
+/// # use reactive_graph::computed::*;
+/// # use reactive_graph::signal::*; let owner = reactive_graph::owner::Owner::new(); owner.set();
+/// # use reactive_graph::prelude::*;
+/// # use reactive_graph::effect::ImmediateEffect;
+/// # use reactive_graph::owner::ArenaItem;
+/// # let owner = reactive_graph::owner::Owner::new(); owner.set();
+/// let a = RwSignal::new(0);
+/// let b = RwSignal::new(0);
+///
+/// // ✅ use effects to interact between reactive state and the outside world
+/// let _drop_guard = ImmediateEffect::new(move || {
+///   // on the next “tick” prints "Value: 0" and subscribes to `a`
+///   println!("Value: {}", a.get());
+/// });
+///
+/// // The effect runs immediately and subscribes to `a`, in the process it prints "Value: 0"
+/// # assert_eq!(a.get(), 0);
+/// a.set(1);
+/// # assert_eq!(a.get(), 1);
+/// // ✅ because it's subscribed to `a`, the effect reruns and prints "Value: 1"
+/// ```
+/// ## Notes
+///
+/// 1. **Scheduling**: Effects run immediately, as soon as any tracked signal changes.
+/// 2. By default, effects do not run unless the `effects` feature is enabled. If you are using
+///    this with a web framework, this generally means that effects **do not run on the server**.
+///    and you can call browser-specific APIs within the effect function without causing issues.
+///    If you need an effect to run on the server, use [`ImmediateEffect::new_isomorphic`].
+#[derive(Debug, Clone)]
+pub struct ImmediateEffect {
+    inner: StoredEffect,
+}
+
+type StoredEffect = Option<Arc<RwLock<inner::EffectInner>>>;
+
+impl Dispose for ImmediateEffect {
+    fn dispose(self) {}
+}
+
+impl ImmediateEffect {
+    /// Creates a new effect which runs immediately, then again as soon as any tracked signal changes.
+    ///
+    /// NOTE: this requires a `Fn` function because it might recurse.
+    /// Use [Self::new_mut] to pass a `FnMut` function, it'll panic on recursion.
+    #[track_caller]
+    #[must_use]
+    pub fn new(fun: impl Fn() + Send + Sync + 'static) -> Self {
+        if !cfg!(feature = "effects") {
+            return Self { inner: None };
+        }
+
+        let inner = inner::EffectInner::new(fun);
+
+        inner.update_if_necessary();
+
+        Self { inner: Some(inner) }
+    }
+    /// Creates a new effect which runs immediately, then again as soon as any tracked signal changes.
+    ///
+    /// # Panics
+    /// Panics on recursion or if triggered in parallel. Also see [Self::new]
+    #[track_caller]
+    #[must_use]
+    pub fn new_mut(fun: impl FnMut() + Send + Sync + 'static) -> Self {
+        const MSG: &str = "The effect recursed or its function panicked.";
+        let fun = Mutex::new(fun);
+        Self::new(move || fun.try_lock().expect(MSG)())
+    }
+    /// Creates a new effect which runs immediately, then again as soon as any tracked signal changes.
+    ///
+    /// NOTE: this requires a `Fn` function because it might recurse.
+    /// NOTE: this effect is automatically cleaned up when the current owner is cleared or disposed.
+    #[track_caller]
+    pub fn new_scoped(fun: impl Fn() + Send + Sync + 'static) {
+        let effect = Self::new(fun);
+
+        on_cleanup(move || effect.dispose());
+    }
+
+    /// Creates a new effect which runs immediately, then again as soon as any tracked signal changes.
+    ///
+    /// This will run whether the `effects` feature is enabled or not.
+    #[track_caller]
+    #[must_use]
+    pub fn new_isomorphic(fun: impl Fn() + Send + Sync + 'static) -> Self {
+        let inner = inner::EffectInner::new(fun);
+
+        inner.update_if_necessary();
+
+        Self { inner: Some(inner) }
+    }
+}
+
+impl ToAnySubscriber for ImmediateEffect {
+    fn to_any_subscriber(&self) -> AnySubscriber {
+        const MSG: &str = "tried to set effect that has been stopped";
+        self.inner.as_ref().expect(MSG).to_any_subscriber()
+    }
+}
+
+impl DefinedAt for ImmediateEffect {
+    fn defined_at(&self) -> Option<&'static Location<'static>> {
+        self.inner.as_ref()?.read().or_poisoned().defined_at()
+    }
+}
+
+mod inner {
+    use crate::{
+        graph::{
+            AnySource, AnySubscriber, ReactiveNode, ReactiveNodeState,
+            SourceSet, Subscriber, ToAnySubscriber, WithObserver,
+        },
+        log_warning,
+        owner::Owner,
+        traits::DefinedAt,
+    };
+    use or_poisoned::OrPoisoned;
+    use std::{
+        panic::Location,
+        sync::{Arc, RwLock, Weak},
+        thread::{self, ThreadId},
+    };
+
+    /// Handles subscription logic for effects.
+    ///
+    /// To handle parallelism and recursion we assign ordered (1..) ids to each run.
+    /// We only keep the sources tracked by the run with the highest id (the last one).
+    ///
+    /// We do this by:
+    /// - Clearing the sources before every run, so the last one clears anything before it.
+    /// - We stop tracking sources after the last run has completed.
+    ///   (A parent run will start before and end after a recursive child run.)
+    /// - To handle parallelism with the last run, we only allow sources to be added by its thread.
+    pub(super) struct EffectInner {
+        #[cfg(any(debug_assertions, leptos_debuginfo))]
+        defined_at: &'static Location<'static>,
+        owner: Owner,
+        state: ReactiveNodeState,
+        /// The number of effect runs in this 'batch'.
+        /// Cleared when no runs are *ongoing* anymore.
+        /// Used to assign ordered ids to each run, and to know when we can clear these values.
+        run_count_start: usize,
+        /// The number of effect runs that have completed in the current 'batch'.
+        /// Cleared when no runs are *ongoing* anymore.
+        /// Used to know when we can clear these values.
+        run_done_count: usize,
+        /// Given ordered ids (1..), the run with the highest id that has completed in this 'batch'.
+        /// Cleared when no runs are *ongoing* anymore.
+        /// Used to know whether the current run is the latest one.
+        run_done_max: usize,
+        /// The [ThreadId] of the run with the highest id.
+        /// Used to prevent over-subscribing during parallel execution with the last run.
+        ///
+        /// ```text
+        /// Thread 1:
+        /// -------------------------
+        ///   ---   ---    =======
+        ///
+        /// Thread 2:
+        /// -------------------------
+        ///             -----------
+        /// ```
+        ///
+        /// In the parallel example above, we can see why we need this.
+        /// The last run is marked using `=`, but another run in the other thread might
+        /// also be gathering sources. So we only allow the run from the correct [ThreadId] to push sources.
+        last_run_thread_id: ThreadId,
+        fun: Arc<dyn Fn() + Send + Sync>,
+        sources: SourceSet,
+        any_subscriber: AnySubscriber,
+    }
+
+    impl EffectInner {
+        #[track_caller]
+        pub fn new(
+            fun: impl Fn() + Send + Sync + 'static,
+        ) -> Arc<RwLock<EffectInner>> {
+            let owner = Owner::new();
+
+            Arc::new_cyclic(|weak| {
+                let any_subscriber = AnySubscriber(
+                    weak.as_ptr() as usize,
+                    Weak::clone(weak) as Weak<dyn Subscriber + Send + Sync>,
+                );
+
+                RwLock::new(EffectInner {
+                    #[cfg(any(debug_assertions, leptos_debuginfo))]
+                    defined_at: Location::caller(),
+                    owner,
+                    state: ReactiveNodeState::Dirty,
+                    run_count_start: 0,
+                    run_done_count: 0,
+                    run_done_max: 0,
+                    last_run_thread_id: thread::current().id(),
+                    fun: Arc::new(fun),
+                    sources: SourceSet::new(),
+                    any_subscriber,
+                })
+            })
+        }
+    }
+
+    impl ToAnySubscriber for Arc<RwLock<EffectInner>> {
+        fn to_any_subscriber(&self) -> AnySubscriber {
+            AnySubscriber(
+                Arc::as_ptr(self) as usize,
+                Arc::downgrade(self) as Weak<dyn Subscriber + Send + Sync>,
+            )
+        }
+    }
+
+    impl ReactiveNode for RwLock<EffectInner> {
+        fn mark_subscribers_check(&self) {}
+
+        fn update_if_necessary(&self) -> bool {
+            let state = {
+                let guard = self.read().or_poisoned();
+
+                if guard.owner.paused() {
+                    return false;
+                }
+
+                guard.state
+            };
+
+            let needs_update = match state {
+                ReactiveNodeState::Clean => false,
+                ReactiveNodeState::Check => {
+                    let sources = self.read().or_poisoned().sources.clone();
+                    sources
+                        .into_iter()
+                        .any(|source| source.update_if_necessary())
+                }
+                ReactiveNodeState::Dirty => true,
+            };
+
+            if needs_update {
+                let mut guard = self.write().or_poisoned();
+
+                let owner = guard.owner.clone();
+                let any_subscriber = guard.any_subscriber.clone();
+                let fun = guard.fun.clone();
+
+                // New run has started.
+                guard.run_count_start += 1;
+                // We get a value for this run, the highest value will be what we keep the sources from.
+                let recursion_count = guard.run_count_start;
+                // We clear the sources before running the effect.
+                // Note that this is tied to the ordering of the initial write lock acquisition
+                // to ensure the last run is also the last to clear them.
+                guard.sources.clear_sources(&any_subscriber);
+                // Only this thread will be able to subscribe.
+                guard.last_run_thread_id = thread::current().id();
+
+                if recursion_count > 2 {
+                    warn_excessive_recursion(&guard);
+                }
+
+                drop(guard);
+
+                // We execute the effect.
+                // Note that *this could happen in parallel across threads*.
+                owner.with_cleanup(|| any_subscriber.with_observer(|| fun()));
+
+                let mut guard = self.write().or_poisoned();
+
+                // This run has completed.
+                guard.run_done_count += 1;
+
+                // We update the done count.
+                // Sources will only be added if recursion_done_max < recursion_count_start.
+                // (Meaning the last run is not done yet.)
+                guard.run_done_max =
+                    Ord::max(recursion_count, guard.run_done_max);
+
+                // The same amount of runs has started and completed,
+                // so we can clear everything up for next time.
+                if guard.run_count_start == guard.run_done_count {
+                    guard.run_count_start = 0;
+                    guard.run_done_count = 0;
+                    guard.run_done_max = 0;
+                    // Can be left unchanged, it'll be set again next time.
+                    // guard.last_run_thread_id = thread::current().id();
+                }
+
+                guard.state = ReactiveNodeState::Clean;
+            }
+
+            needs_update
+        }
+
+        fn mark_check(&self) {
+            self.write().or_poisoned().state = ReactiveNodeState::Check;
+            self.update_if_necessary();
+        }
+
+        fn mark_dirty(&self) {
+            self.write().or_poisoned().state = ReactiveNodeState::Dirty;
+            self.update_if_necessary();
+        }
+    }
+
+    impl Subscriber for RwLock<EffectInner> {
+        fn add_source(&self, source: AnySource) {
+            let mut guard = self.write().or_poisoned();
+            if guard.run_done_max < guard.run_count_start
+                && guard.last_run_thread_id == thread::current().id()
+            {
+                guard.sources.insert(source);
+            }
+        }
+
+        fn clear_sources(&self, subscriber: &AnySubscriber) {
+            self.write().or_poisoned().sources.clear_sources(subscriber);
+        }
+    }
+
+    impl DefinedAt for EffectInner {
+        fn defined_at(&self) -> Option<&'static Location<'static>> {
+            #[cfg(any(debug_assertions, leptos_debuginfo))]
+            {
+                Some(self.defined_at)
+            }
+            #[cfg(not(any(debug_assertions, leptos_debuginfo)))]
+            {
+                None
+            }
+        }
+    }
+
+    impl std::fmt::Debug for EffectInner {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.debug_struct("EffectInner")
+                .field("owner", &self.owner)
+                .field("state", &self.state)
+                .field("sources", &self.sources)
+                .field("any_subscriber", &self.any_subscriber)
+                .finish()
+        }
+    }
+
+    fn warn_excessive_recursion(effect: &EffectInner) {
+        const MSG: &str = "ImmediateEffect recursed more than once.";
+        match effect.defined_at() {
+            Some(defined_at) => {
+                log_warning(format_args!("{MSG} Defined at: {}", defined_at));
+            }
+            None => {
+                log_warning(format_args!("{MSG}"));
+            }
+        }
+    }
+}

reactive_graph/src/effect/inner.rs

@@ -30,21 +30,19 @@ impl ReactiveNode for RwLock<EffectInner> {
 
     fn update_if_necessary(&self) -> bool {
         let mut guard = self.write().or_poisoned();
-        let (is_dirty, sources) =
-            (guard.dirty, (!guard.dirty).then(|| guard.sources.clone()));
 
-        if is_dirty {
+        if guard.dirty {
             guard.dirty = false;
             return true;
         }
 
+        let sources = guard.sources.clone();
+
         drop(guard);
-        for source in sources.into_iter().flatten() {
-            if source.update_if_necessary() {
-                return true;
-            }
-        }
-        false
+
+        sources
+            .into_iter()
+            .any(|source| source.update_if_necessary())
     }
 
     fn mark_check(&self) {

reactive_graph/src/effect/render_effect.rs

@@ -91,9 +91,11 @@ where
 
                     async move {
                         while rx.next().await.is_some() {
-                            if subscriber.with_observer(|| {
-                                subscriber.update_if_necessary()
-                            }) {
+                            if !owner.paused()
+                                && subscriber.with_observer(|| {
+                                    subscriber.update_if_necessary()
+                                })
+                            {
                                 subscriber.clear_sources(&subscriber);
 
                                 let old_value = mem::take(
@@ -159,8 +161,10 @@ where
 
                 async move {
                     while rx.next().await.is_some() {
-                        if subscriber
-                            .with_observer(|| subscriber.update_if_necessary())
+                        if !owner.paused()
+                            && subscriber.with_observer(|| {
+                                subscriber.update_if_necessary()
+                            })
                         {
                             subscriber.clear_sources(&subscriber);
 

reactive_graph/src/lib.rs

@@ -48,10 +48,10 @@
 //!
 //! ## Design Principles and Assumptions
 //! - **Effects are expensive.** The library is built on the assumption that the side effects
-//!    (making a network request, rendering something to the DOM, writing to disk) are orders of
-//!    magnitude more expensive than propagating signal updates. As a result, the algorithm is
-//!    designed to avoid re-running side effects unnecessarily, and is willing to sacrifice a small
-//!    amount of raw update speed to that goal.
+//!   (making a network request, rendering something to the DOM, writing to disk) are orders of
+//!   magnitude more expensive than propagating signal updates. As a result, the algorithm is
+//!   designed to avoid re-running side effects unnecessarily, and is willing to sacrifice a small
+//!   amount of raw update speed to that goal.
 //! - **Automatic dependency tracking.** Dependencies are not specified as a compile-time list, but
 //!   tracked at runtime. This in turn enables **dynamic dependency tracking**: subscribers
 //!   unsubscribe from their sources between runs, which means that a subscriber that contains a

reactive_graph/src/owner.rs

@@ -130,6 +130,7 @@ impl Owner {
                     .and_then(|parent| parent.upgrade())
                     .map(|parent| parent.read().or_poisoned().arena.clone())
                     .unwrap_or_default(),
+                paused: false,
             })),
             #[cfg(feature = "hydration")]
             shared_context,
@@ -163,6 +164,7 @@ impl Owner {
                 children: Default::default(),
                 #[cfg(feature = "sandboxed-arenas")]
                 arena: Default::default(),
+                paused: false,
             })),
             #[cfg(feature = "hydration")]
             shared_context,
@@ -174,8 +176,10 @@ impl Owner {
     /// Creates a new `Owner` that is the child of the current `Owner`, if any.
     pub fn child(&self) -> Self {
         let parent = Some(Arc::downgrade(&self.inner));
+        let mut inner = self.inner.write().or_poisoned();
         #[cfg(feature = "sandboxed-arenas")]
-        let arena = self.inner.read().or_poisoned().arena.clone();
+        let arena = inner.arena.clone();
+        let paused = inner.paused;
         let child = Self {
             inner: Arc::new(RwLock::new(OwnerInner {
                 parent,
@@ -185,15 +189,12 @@ impl Owner {
                 children: Default::default(),
                 #[cfg(feature = "sandboxed-arenas")]
                 arena,
+                paused,
             })),
             #[cfg(feature = "hydration")]
             shared_context: self.shared_context.clone(),
         };
-        self.inner
-            .write()
-            .or_poisoned()
-            .children
-            .push(Arc::downgrade(&child.inner));
+        inner.children.push(Arc::downgrade(&child.inner));
         child
     }
 
@@ -207,9 +208,7 @@ impl Owner {
     /// Runs the given function with this as the current `Owner`.
     pub fn with<T>(&self, fun: impl FnOnce() -> T) -> T {
         let prev = {
-            OWNER.with(|o| {
-                mem::replace(&mut *o.borrow_mut(), Some(self.clone()))
-            })
+            OWNER.with(|o| Option::replace(&mut *o.borrow_mut(), self.clone()))
         };
         #[cfg(feature = "sandboxed-arenas")]
         Arena::set(&self.inner.read().or_poisoned().arena);
@@ -337,6 +336,47 @@ impl Owner {
 
         inner(Box::new(fun))
     }
+
+    /// Pauses the execution of side effects for this owner, and any of its descendants.
+    ///
+    /// If this owner is the owner for an [`Effect`](crate::effect::Effect) or [`RenderEffect`](crate::effect::RenderEffect), this effect will not run until [`Owner::resume`] is called. All children of this effects are also paused.
+    ///
+    /// Any notifications will be ignored; effects that are notified will paused will not run when
+    /// resumed, until they are notified again by a source after being resumed.
+    pub fn pause(&self) {
+        let mut stack = Vec::with_capacity(16);
+        stack.push(Arc::downgrade(&self.inner));
+        while let Some(curr) = stack.pop() {
+            if let Some(curr) = curr.upgrade() {
+                let mut curr = curr.write().or_poisoned();
+                curr.paused = true;
+                stack.extend(curr.children.iter().map(Weak::clone));
+            }
+        }
+    }
+
+    /// Whether this owner has been paused by [`Owner::pause`].
+    pub fn paused(&self) -> bool {
+        self.inner.read().or_poisoned().paused
+    }
+
+    /// Resumes side effects that have been paused by [`Owner::pause`].
+    ///
+    /// All children will also be resumed.
+    ///
+    /// This will *not* cause side effects that were notified while paused to run, until they are
+    /// notified again by a source after being resumed.
+    pub fn resume(&self) {
+        let mut stack = Vec::with_capacity(16);
+        stack.push(Arc::downgrade(&self.inner));
+        while let Some(curr) = stack.pop() {
+            if let Some(curr) = curr.upgrade() {
+                let mut curr = curr.write().or_poisoned();
+                curr.paused = false;
+                stack.extend(curr.children.iter().map(Weak::clone));
+            }
+        }
+    }
 }
 
 #[doc(hidden)]
@@ -363,6 +403,7 @@ pub(crate) struct OwnerInner {
     pub children: Vec<Weak<RwLock<OwnerInner>>>,
     #[cfg(feature = "sandboxed-arenas")]
     arena: Arc<RwLock<ArenaMap>>,
+    paused: bool,
 }
 
 impl Debug for OwnerInner {

reactive_graph/src/signal/subscriber_traits.rs

@@ -55,7 +55,7 @@ impl<T: AsSubscriberSet + DefinedAt> ReactiveNode for T {
 
     fn mark_subscribers_check(&self) {
         if let Some(inner) = self.as_subscriber_set() {
-            let subs = inner.borrow().write().unwrap().take();
+            let subs = inner.borrow().read().unwrap().clone();
             for sub in subs {
                 sub.mark_dirty();
             }

reactive_graph/src/transition.rs

@@ -37,9 +37,9 @@ impl AsyncTransition {
         let (tx, rx) = mpsc::channel();
         let global_transition = global_transition();
         let inner = TransitionInner { tx };
-        let prev = std::mem::replace(
+        let prev = Option::replace(
             &mut *global_transition.write().or_poisoned(),
-            Some(inner.clone()),
+            inner.clone(),
         );
         let value = action().await;
         _ = std::mem::replace(

reactive_graph/tests/effect.rs

@@ -196,3 +196,62 @@ async fn recursive_effect_runs_recursively() {
         })
         .await;
 }
+
+#[cfg(feature = "effects")]
+#[tokio::test]
+async fn paused_effect_pauses() {
+    use imports::*;
+    use reactive_graph::owner::StoredValue;
+
+    _ = Executor::init_tokio();
+    let owner = Owner::new();
+    owner.set();
+
+    task::LocalSet::new()
+        .run_until(async {
+            let a = RwSignal::new(-1);
+
+            // simulate an arbitrary side effect
+            let runs = StoredValue::new(0);
+
+            let owner = StoredValue::new(None);
+
+            Effect::new({
+                move || {
+                    *owner.write_value() = Owner::current();
+
+                    let _ = a.get();
+                    *runs.write_value() += 1;
+                }
+            });
+
+            Executor::tick().await;
+            assert_eq!(runs.get_value(), 1);
+
+            println!("setting to 1");
+            a.set(1);
+
+            Executor::tick().await;
+            assert_eq!(runs.get_value(), 2);
+
+            println!("pausing");
+            owner.get_value().unwrap().pause();
+
+            println!("setting to 2");
+            a.set(2);
+
+            Executor::tick().await;
+            assert_eq!(runs.get_value(), 2);
+
+            println!("resuming");
+            owner.get_value().unwrap().resume();
+
+            println!("setting to 3");
+            a.set(3);
+
+            Executor::tick().await;
+            println!("checking value");
+            assert_eq!(runs.get_value(), 3);
+        })
+        .await
+}

reactive_graph/tests/effect_immediate.rs

@@ -0,0 +1,227 @@
+#[cfg(feature = "effects")]
+pub mod imports {
+    pub use any_spawner::Executor;
+    pub use reactive_graph::{
+        effect::ImmediateEffect, owner::Owner, prelude::*, signal::RwSignal,
+    };
+    pub use std::sync::{Arc, RwLock};
+    pub use tokio::task;
+}
+
+#[cfg(feature = "effects")]
+#[test]
+fn effect_runs() {
+    use imports::*;
+
+    let owner = Owner::new();
+    owner.set();
+
+    let a = RwSignal::new(-1);
+
+    // simulate an arbitrary side effect
+    let b = Arc::new(RwLock::new(String::new()));
+
+    let _guard = ImmediateEffect::new({
+        let b = b.clone();
+        move || {
+            let formatted = format!("Value is {}", a.get());
+            *b.write().unwrap() = formatted;
+        }
+    });
+    assert_eq!(b.read().unwrap().as_str(), "Value is -1");
+
+    println!("setting to 1");
+    a.set(1);
+    assert_eq!(b.read().unwrap().as_str(), "Value is 1");
+}
+
+#[cfg(feature = "effects")]
+#[test]
+fn dynamic_dependencies() {
+    use imports::*;
+
+    let owner = Owner::new();
+    owner.set();
+
+    let first = RwSignal::new("Greg");
+    let last = RwSignal::new("Johnston");
+    let use_last = RwSignal::new(true);
+
+    let combined_count = Arc::new(RwLock::new(0));
+
+    let _guard = ImmediateEffect::new({
+        let combined_count = Arc::clone(&combined_count);
+        move || {
+            *combined_count.write().unwrap() += 1;
+            if use_last.get() {
+                println!("{} {}", first.get(), last.get());
+            } else {
+                println!("{}", first.get());
+            }
+        }
+    });
+
+    assert_eq!(*combined_count.read().unwrap(), 1);
+
+    println!("\nsetting `first` to Bob");
+    first.set("Bob");
+    assert_eq!(*combined_count.read().unwrap(), 2);
+
+    println!("\nsetting `last` to Bob");
+    last.set("Thompson");
+    assert_eq!(*combined_count.read().unwrap(), 3);
+
+    println!("\nsetting `use_last` to false");
+    use_last.set(false);
+    assert_eq!(*combined_count.read().unwrap(), 4);
+
+    println!("\nsetting `last` to Jones");
+    last.set("Jones");
+    assert_eq!(*combined_count.read().unwrap(), 4);
+
+    println!("\nsetting `last` to Jones");
+    last.set("Smith");
+    assert_eq!(*combined_count.read().unwrap(), 4);
+
+    println!("\nsetting `last` to Stevens");
+    last.set("Stevens");
+    assert_eq!(*combined_count.read().unwrap(), 4);
+
+    println!("\nsetting `use_last` to true");
+    use_last.set(true);
+    assert_eq!(*combined_count.read().unwrap(), 5);
+}
+
+#[cfg(feature = "effects")]
+#[test]
+fn recursive_effect_runs_recursively() {
+    use imports::*;
+
+    let owner = Owner::new();
+    owner.set();
+
+    let s = RwSignal::new(0);
+
+    let logged_values = Arc::new(RwLock::new(Vec::new()));
+
+    let _guard = ImmediateEffect::new({
+        let logged_values = Arc::clone(&logged_values);
+        move || {
+            let a = s.get();
+            println!("a = {a}");
+            logged_values.write().unwrap().push(a);
+            if a == 0 {
+                return;
+            }
+            s.set(0);
+        }
+    });
+
+    s.set(1);
+    s.set(2);
+    s.set(3);
+
+    assert_eq!(0, s.get_untracked());
+    assert_eq!(&*logged_values.read().unwrap(), &[0, 1, 0, 2, 0, 3, 0]);
+}
+
+#[cfg(feature = "effects")]
+#[test]
+fn paused_effect_pauses() {
+    use imports::*;
+    use reactive_graph::owner::StoredValue;
+
+    let owner = Owner::new();
+    owner.set();
+
+    let a = RwSignal::new(-1);
+
+    // simulate an arbitrary side effect
+    let runs = StoredValue::new(0);
+
+    let owner = StoredValue::new(None);
+
+    let _guard = ImmediateEffect::new({
+        move || {
+            *owner.write_value() = Owner::current();
+
+            let _ = a.get();
+            *runs.write_value() += 1;
+        }
+    });
+
+    assert_eq!(runs.get_value(), 1);
+
+    println!("setting to 1");
+    a.set(1);
+
+    assert_eq!(runs.get_value(), 2);
+
+    println!("pausing");
+    owner.get_value().unwrap().pause();
+
+    println!("setting to 2");
+    a.set(2);
+
+    assert_eq!(runs.get_value(), 2);
+
+    println!("resuming");
+    owner.get_value().unwrap().resume();
+
+    println!("setting to 3");
+    a.set(3);
+
+    println!("checking value");
+    assert_eq!(runs.get_value(), 3);
+}
+
+#[cfg(feature = "effects")]
+#[test]
+#[ignore = "Parallel signal access can panic."]
+fn threaded_chaos_effect() {
+    use imports::*;
+    use reactive_graph::owner::StoredValue;
+
+    const SIGNAL_COUNT: usize = 5;
+    const THREAD_COUNT: usize = 10;
+
+    let owner = Owner::new();
+    owner.set();
+
+    let signals = vec![RwSignal::new(0); SIGNAL_COUNT];
+
+    let runs = StoredValue::new(0);
+
+    let _guard = ImmediateEffect::new({
+        let signals = signals.clone();
+        move || {
+            *runs.write_value() += 1;
+
+            let mut values = vec![];
+            for s in &signals {
+                let v = s.get();
+                values.push(v);
+                if v != 0 {
+                    s.set(v - 1);
+                }
+            }
+            println!("{values:?}");
+        }
+    });
+
+    std::thread::scope(|s| {
+        for _ in 0..THREAD_COUNT {
+            let signals = signals.clone();
+            s.spawn(move || {
+                for s in &signals {
+                    s.set(1);
+                }
+            });
+        }
+    });
+
+    assert_eq!(runs.get_value(), 1 + THREAD_COUNT * SIGNAL_COUNT);
+
+    let values: Vec<_> = signals.iter().map(|s| s.get_untracked()).collect();
+    println!("FINAL: {values:?}");
+}

reactive_stores/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reactive_stores"
-version = "0.1.5"
+version = "0.1.7"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"
@@ -11,7 +11,7 @@ edition.workspace = true
 
 [dependencies]
 guardian = "1.2"
-itertools = "0.13.0"
+itertools = { workspace = true }
 or_poisoned = { workspace = true }
 paste = "1.0"
 reactive_graph = { workspace = true }
@@ -19,7 +19,7 @@ rustc-hash = "2.0"
 reactive_stores_macro = { workspace = true }
 
 [dev-dependencies]
-tokio = { version = "1.41", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1.43", features = ["rt-multi-thread", "macros"] }
 tokio-test = { version = "0.4.4" }
 any_spawner = { workspace = true, features = ["futures-executor", "tokio"] }
 reactive_graph = { workspace = true, features = ["effects"] }

reactive_stores/src/arc_field.rs

@@ -38,6 +38,20 @@ where
     track_field: Arc<dyn Fn() + Send + Sync>,
 }
 
+impl<T> Debug for ArcField<T>
+where
+    T: 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut f = f.debug_struct("ArcField");
+        #[cfg(any(debug_assertions, leptos_debuginfo))]
+        let f = f.field("defined_at", &self.defined_at);
+        f.field("path", &self.path)
+            .field("trigger", &self.trigger)
+            .finish()
+    }
+}
+
 pub struct StoreFieldReader<T>(Box<dyn Deref<Target = T>>);
 
 impl<T> StoreFieldReader<T> {

reactive_stores/src/field.rs

@@ -10,7 +10,6 @@ use reactive_graph::{
         DefinedAt, IsDisposed, Notify, ReadUntracked, Track, UntrackableGuard,
         Write,
     },
-    unwrap_signal,
 };
 use std::{
     fmt::Debug,
@@ -32,6 +31,19 @@ where
     inner: ArenaItem<ArcField<T>, S>,
 }
 
+impl<T, S> Debug for Field<T, S>
+where
+    T: 'static,
+    S: Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut f = f.debug_struct("Field");
+        #[cfg(any(debug_assertions, leptos_debuginfo))]
+        let f = f.field("defined_at", &self.defined_at);
+        f.field("inner", &self.inner).finish()
+    }
+}
+
 impl<T, S> StoreField for Field<T, S>
 where
     S: Storage<ArcField<T>>,
@@ -44,14 +56,14 @@ where
         self.inner
             .try_get_value()
             .map(|inner| inner.get_trigger(path))
-            .unwrap_or_else(unwrap_signal!(self))
+            .unwrap_or_default()
     }
 
     fn path(&self) -> impl IntoIterator<Item = StorePathSegment> {
         self.inner
             .try_get_value()
             .map(|inner| inner.path().into_iter().collect::<Vec<_>>())
-            .unwrap_or_else(unwrap_signal!(self))
+            .unwrap_or_default()
     }
 
     fn reader(&self) -> Option<Self::Reader> {
@@ -82,6 +94,21 @@ where
     }
 }
 
+impl<T, S> From<ArcField<T>> for Field<T, S>
+where
+    T: 'static,
+    S: Storage<ArcField<T>>,
+{
+    #[track_caller]
+    fn from(value: ArcField<T>) -> Self {
+        Field {
+            #[cfg(any(debug_assertions, leptos_debuginfo))]
+            defined_at: Location::caller(),
+            inner: ArenaItem::new_with_storage(value),
+        }
+    }
+}
+
 impl<T, S> From<ArcStore<T>> for Field<T, S>
 where
     T: Send + Sync + 'static,

reactive_stores/src/keyed.rs

@@ -148,11 +148,8 @@ where
 {
     fn latest_keys(&self) -> Vec<K> {
         self.reader()
-            .expect("trying to update keys")
-            .deref()
-            .into_iter()
-            .map(|n| (self.key_fn)(n))
-            .collect()
+            .map(|r| r.deref().into_iter().map(|n| (self.key_fn)(n)).collect())
+            .unwrap_or_default()
     }
 }
 
@@ -483,8 +480,7 @@ where
                 || self.inner.latest_keys(),
             )
             .flatten()
-            .map(|(_, idx)| idx)
-            .expect("reading from a keyed field that has not yet been created");
+            .map(|(_, idx)| idx)?;
 
         Some(WriteGuard::new(
             trigger.children,
@@ -654,13 +650,15 @@ where
         self.track_field();
 
         // get the current length of the field by accessing slice
-        let reader = self
-            .reader()
-            .expect("creating iterator from unavailable store field");
+        let reader = self.reader();
+
         let keys = reader
-            .into_iter()
-            .map(|item| (self.key_fn)(item))
-            .collect::<VecDeque<_>>();
+            .map(|r| {
+                r.into_iter()
+                    .map(|item| (self.key_fn)(item))
+                    .collect::<VecDeque<_>>()
+            })
+            .unwrap_or_default();
 
         // return the iterator
         StoreFieldKeyedIter { inner: self, keys }

reactive_stores/src/option.rs

@@ -1,5 +1,5 @@
 use crate::{StoreField, Subfield};
-use reactive_graph::traits::{Read, ReadUntracked};
+use reactive_graph::traits::{FlattenOptionRefOption, Read, ReadUntracked};
 use std::ops::Deref;
 
 /// Extends optional store fields, with the ability to unwrap or map over them.
@@ -13,6 +13,13 @@ where
     /// Provides access to the inner value, as a subfield, unwrapping the outer value.
     fn unwrap(self) -> Subfield<Self, Option<Self::Output>, Self::Output>;
 
+    /// Inverts a subfield of an `Option` to an `Option` of a subfield.
+    fn invert(
+        self,
+    ) -> Option<Subfield<Self, Option<Self::Output>, Self::Output>> {
+        self.map(|f| f)
+    }
+
     /// Reactively maps over the field.
     ///
     /// This returns `None` if the subfield is currently `None`,
@@ -56,7 +63,7 @@ where
         self,
         map_fn: impl FnOnce(Subfield<S, Option<T>, T>) -> U,
     ) -> Option<U> {
-        if self.read().is_some() {
+        if self.try_read().as_deref().flatten().is_some() {
             Some(map_fn(self.unwrap()))
         } else {
             None
@@ -67,7 +74,7 @@ where
         self,
         map_fn: impl FnOnce(Subfield<S, Option<T>, T>) -> U,
     ) -> Option<U> {
-        if self.read_untracked().is_some() {
+        if self.try_read_untracked().as_deref().flatten().is_some() {
             Some(map_fn(self.unwrap()))
         } else {
             None
@@ -77,11 +84,12 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::{self as reactive_stores, Store};
+    use crate::{self as reactive_stores, Patch as _, Store};
     use reactive_graph::{
         effect::Effect,
         traits::{Get, Read, ReadUntracked, Set, Write},
     };
+    use reactive_stores_macro::Patch;
     use std::sync::{
         atomic::{AtomicUsize, Ordering},
         Arc,
@@ -237,4 +245,115 @@ mod tests {
         assert_eq!(parent_count.load(Ordering::Relaxed), 3);
         assert_eq!(inner_count.load(Ordering::Relaxed), 3);
     }
+
+    #[tokio::test]
+    async fn patch() {
+        use crate::OptionStoreExt;
+
+        #[derive(Debug, Clone, Store, Patch)]
+        struct Outer {
+            inner: Option<Inner>,
+        }
+
+        #[derive(Debug, Clone, Store, Patch)]
+        struct Inner {
+            first: String,
+            second: String,
+        }
+
+        let store = Store::new(Outer {
+            inner: Some(Inner {
+                first: "A".to_owned(),
+                second: "B".to_owned(),
+            }),
+        });
+
+        _ = any_spawner::Executor::init_tokio();
+
+        let parent_count = Arc::new(AtomicUsize::new(0));
+        let inner_first_count = Arc::new(AtomicUsize::new(0));
+        let inner_second_count = Arc::new(AtomicUsize::new(0));
+
+        Effect::new_sync({
+            let parent_count = Arc::clone(&parent_count);
+            move |prev: Option<()>| {
+                if prev.is_none() {
+                    println!("parent: first run");
+                } else {
+                    println!("parent: next run");
+                }
+
+                println!("  value = {:?}", store.inner().get());
+                parent_count.fetch_add(1, Ordering::Relaxed);
+            }
+        });
+        Effect::new_sync({
+            let inner_first_count = Arc::clone(&inner_first_count);
+            move |prev: Option<()>| {
+                if prev.is_none() {
+                    println!("inner_first: first run");
+                } else {
+                    println!("inner_first: next run");
+                }
+
+                println!(
+                    "  value = {:?}",
+                    store.inner().map(|inner| inner.first().get())
+                );
+                inner_first_count.fetch_add(1, Ordering::Relaxed);
+            }
+        });
+        Effect::new_sync({
+            let inner_second_count = Arc::clone(&inner_second_count);
+            move |prev: Option<()>| {
+                if prev.is_none() {
+                    println!("inner_second: first run");
+                } else {
+                    println!("inner_second: next run");
+                }
+
+                println!(
+                    "  value = {:?}",
+                    store.inner().map(|inner| inner.second().get())
+                );
+                inner_second_count.fetch_add(1, Ordering::Relaxed);
+            }
+        });
+
+        tick().await;
+        assert_eq!(parent_count.load(Ordering::Relaxed), 1);
+        assert_eq!(inner_first_count.load(Ordering::Relaxed), 1);
+        assert_eq!(inner_second_count.load(Ordering::Relaxed), 1);
+
+        store.patch(Outer {
+            inner: Some(Inner {
+                first: "A".to_string(),
+                second: "C".to_string(),
+            }),
+        });
+
+        tick().await;
+        assert_eq!(parent_count.load(Ordering::Relaxed), 1);
+        assert_eq!(inner_first_count.load(Ordering::Relaxed), 1);
+        assert_eq!(inner_second_count.load(Ordering::Relaxed), 2);
+
+        store.patch(Outer { inner: None });
+
+        tick().await;
+        assert_eq!(parent_count.load(Ordering::Relaxed), 2);
+        assert_eq!(inner_first_count.load(Ordering::Relaxed), 2);
+        assert_eq!(inner_second_count.load(Ordering::Relaxed), 3);
+
+        store.patch(Outer {
+            inner: Some(Inner {
+                first: "A".to_string(),
+                second: "B".to_string(),
+            }),
+        });
+
+        tick().await;
+        assert_eq!(parent_count.load(Ordering::Relaxed), 3);
+        assert_eq!(inner_first_count.load(Ordering::Relaxed), 3);
+        assert_eq!(inner_second_count.load(Ordering::Relaxed), 4);
+    }
 }

reactive_stores/src/patch.rs

@@ -114,6 +114,35 @@ patch_primitives! {
     NonZeroUsize
 }
 
+impl<T> PatchField for Option<T>
+where
+    T: PatchField,
+{
+    fn patch_field(
+        &mut self,
+        new: Self,
+        path: &StorePath,
+        notify: &mut dyn FnMut(&StorePath),
+    ) {
+        match (self, new) {
+            (None, None) => {}
+            (old @ Some(_), None) => {
+                old.take();
+                notify(path);
+            }
+            (old @ None, new @ Some(_)) => {
+                *old = new;
+                notify(path);
+            }
+            (Some(old), Some(new)) => {
+                let mut new_path = path.to_owned();
+                new_path.push(0);
+                old.patch_field(new, &new_path, notify);
+            }
+        }
+    }
+}
+
 impl<T> PatchField for Vec<T>
 where
     T: PatchField,

reactive_stores/src/store_field.rs

@@ -9,8 +9,7 @@ use reactive_graph::{
         guards::{Plain, UntrackedWriteGuard, WriteGuard},
         ArcTrigger,
     },
-    traits::{DefinedAt, Track, UntrackableGuard},
-    unwrap_signal,
+    traits::{Track, UntrackableGuard},
 };
 use std::{iter, ops::Deref, sync::Arc};
 
@@ -105,7 +104,7 @@ where
         self.inner
             .try_get_value()
             .map(|n| n.get_trigger(path))
-            .unwrap_or_else(unwrap_signal!(self))
+            .unwrap_or_default()
     }
 
     #[track_caller]
@@ -113,7 +112,7 @@ where
         self.inner
             .try_get_value()
             .map(|n| n.path().into_iter().collect::<Vec<_>>())
-            .unwrap_or_else(unwrap_signal!(self))
+            .unwrap_or_default()
     }
 
     #[track_caller]

reactive_stores/src/subfield.rs

@@ -9,9 +9,10 @@ use reactive_graph::{
         ArcTrigger,
     },
     traits::{
-        DefinedAt, IsDisposed, Notify, ReadUntracked, Track, UntrackableGuard,
-        Write,
+        DefinedAt, Get as _, IsDisposed, Notify, ReadUntracked, Track,
+        UntrackableGuard, Write,
     },
+    wrappers::read::Signal,
 };
 use std::{iter, marker::PhantomData, ops::DerefMut, panic::Location};
 
@@ -99,6 +100,9 @@ where
 
         let mut full_path = self.path().into_iter().collect::<StorePath>();
         full_path.pop();
+
+        // build a list of triggers, starting with the full path to this node and ending with the root
+        // this will mean that the root is the final item, and this path is first
         let mut triggers = Vec::with_capacity(full_path.len());
         triggers.push(trigger.this.clone());
         loop {
@@ -109,6 +113,17 @@ where
             }
             full_path.pop();
         }
+
+        // when the WriteGuard is dropped, each trigger will be notified, in order
+        // reversing the list will cause the triggers to be notified starting from the root,
+        // then to each child down to this one
+        //
+        // notifying from the root down is important for things like OptionStoreExt::map()/unwrap(),
+        // where it's really important that any effects that subscribe to .is_some() run before effects
+        // that subscribe to the inner value, so that the inner effect can be canceled if the outer switches to `None`
+        // (see https://github.com/leptos-rs/leptos/issues/3704)
+        triggers.reverse();
+
         let guard = WriteGuard::new(triggers, parent);
 
         Some(MappedMut::new(guard, self.read, self.write))
@@ -223,3 +238,14 @@ where
         })
     }
 }
+
+impl<Inner, Prev, T> From<Subfield<Inner, Prev, T>> for Signal<T>
+where
+    Inner: StoreField<Value = Prev> + Track + Send + Sync + 'static,
+    Prev: 'static,
+    T: Send + Sync + Clone + 'static,
+{
+    fn from(subfield: Subfield<Inner, Prev, T>) -> Self {
+        Signal::derive(move || subfield.get())
+    }
+}

reactive_stores_macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reactive_stores_macro"
-version = "0.1.5"
+version = "0.1.7"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"
@@ -13,7 +13,7 @@ edition.workspace = true
 proc-macro = true
 
 [dependencies]
-convert_case = "0.6"
+convert_case = "0.7"
 proc-macro-error2 = "2.0"
 proc-macro2 = "1.0"
 quote = "1.0"

reactive_stores_macro/src/lib.rs

@@ -79,7 +79,7 @@ impl Parse for Model {
 
 #[derive(Clone)]
 enum SubfieldMode {
-    Keyed(ExprClosure, Type),
+    Keyed(ExprClosure, Box<Type>),
     Skip,
 }
 
@@ -87,15 +87,15 @@ impl Parse for SubfieldMode {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let mode: Ident = input.parse()?;
         if mode == "key" {
-            let _col: Token!(:) = input.parse()?;
+            let _col: Token![:] = input.parse()?;
             let ty: Type = input.parse()?;
-            let _eq: Token!(=) = input.parse()?;
-            let ident: ExprClosure = input.parse()?;
-            Ok(SubfieldMode::Keyed(ident, ty))
+            let _eq: Token![=] = input.parse()?;
+            let closure: ExprClosure = input.parse()?;
+            Ok(SubfieldMode::Keyed(closure, Box::new(ty)))
         } else if mode == "skip" {
             Ok(SubfieldMode::Skip)
         } else {
-            Err(input.error("expected `key = <ident>: <Type>`"))
+            Err(input.error("expected `key: <Type> = <closure>`"))
         }
     }
 }

router/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_router"
-version = "0.7.5"
+version = "0.7.7"
 authors = ["Greg Johnston", "Ben Wishovich"]
 license = "MIT"
 readme = "../README.md"
@@ -20,7 +20,7 @@ tachys = { workspace = true, features = ["reactive_graph"] }
 futures = "0.3.31"
 url = "2.5"
 js-sys = { version = "0.3.74" }
-wasm-bindgen = { version = "0.2.97" }
+wasm-bindgen = { workspace = true }
 tracing = { version = "0.1.41", optional = true }
 once_cell = "1.20"
 send_wrapper = "0.6.0"

router/src/location/mod.rs

@@ -91,7 +91,9 @@ impl Url {
             path.push_str(&self.search);
         }
         if !self.hash.is_empty() {
-            path.push('#');
+            if !self.hash.starts_with('#') {
+                path.push('#');
+            }
             path.push_str(&self.hash);
         }
         path
@@ -123,14 +125,20 @@ impl Url {
 
         #[cfg(not(feature = "ssr"))]
         {
-            js_sys::decode_uri_component(s).unwrap().into()
+            match js_sys::decode_uri_component(s) {
+                Ok(v) => v.into(),
+                Err(_) => s.into(),
+            }
         }
     }
 
     pub fn unescape_minimal(s: &str) -> String {
         #[cfg(not(feature = "ssr"))]
         {
-            js_sys::decode_uri(s).unwrap().into()
+            match js_sys::decode_uri(s) {
+                Ok(v) => v.into(),
+                Err(_) => s.into(),
+            }
         }
 
         #[cfg(feature = "ssr")]

router/src/matching/horizontal/param_segments.rs

@@ -58,7 +58,7 @@ impl PossibleRouteMatch for ParamSegment {
             }
         }
 
-        if matched_len == 0 {
+        if matched_len == 0 || (matched_len == 1 && path.starts_with('/')) {
             return None;
         }
 

router/src/nested_router.rs

@@ -458,7 +458,7 @@ where
     }
 }
 
-type OutletViewFn = Box<dyn Fn() -> Suspend<AnyView> + Send>;
+type OutletViewFn = Box<dyn FnMut() -> Suspend<AnyView> + Send>;
 
 pub(crate) struct RouteContext {
     id: RouteMatchId,
@@ -752,8 +752,8 @@ where
 
                     // assign a new owner, so that contexts and signals owned by the previous route
                     // in this outlet can be dropped
-                    let old_owner =
-                        mem::replace(&mut current.owner, parent.child());
+                    let mut old_owner =
+                        Some(mem::replace(&mut current.owner, parent.child()));
                     let owner = current.owner.clone();
                     let (full_tx, full_rx) = oneshot::channel();
                     let full_tx = Mutex::new(Some(full_tx));
@@ -780,6 +780,7 @@ where
                                         let view = view.clone();
                                         let full_tx =
                                             full_tx.lock().or_poisoned().take();
+                                        let old_owner = old_owner.take();
                                         Suspend::new(Box::pin(async move {
                                             let view = SendWrapper::new(
                                                 owner.with(|| {
@@ -795,6 +796,10 @@ where
                                                 }),
                                             );
                                             let view = view.await;
+                                            if let Some(old_owner) = old_owner {
+                                                old_owner.cleanup();
+                                            }
+
                                             if let Some(tx) = full_tx {
                                                 _ = tx.send(());
                                             }
@@ -803,7 +808,7 @@ where
                                             })
                                         }))
                                     });
-                                drop(old_owner);
+
                                 drop(old_params);
                                 drop(old_url);
                                 drop(old_matched);
@@ -887,7 +892,7 @@ where
             trigger, view_fn, ..
         } = ctx;
         trigger.track();
-        let view_fn = view_fn.lock().or_poisoned();
+        let mut view_fn = view_fn.lock().or_poisoned();
         view_fn()
     }
 }

router_macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_router_macro"
-version = "0.7.5"
+version = "0.7.7"
 authors = ["Greg Johnston", "Ben Wishovich"]
 license = "MIT"
 readme = "../README.md"

scripts/update_nightly.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+
+set -e
+
+exit_error() {
+    echo "ERROR: $1" >&2
+    exit 1
+}
+
+current_dir=$(pwd)
+
+if [[ "$current_dir" != */leptos ]]; then
+    exit_error "Current directory does not end with leptos"
+fi
+
+# Check if a date is provided as an argument
+if [ $# -eq 1 ]; then
+    NEW_DATE=$1
+    echo -n "Will use the provided date: "
+else
+    # Use current date if no date is provided
+    NEW_DATE=$(date +"%Y-%m-%d")
+    echo -n "Will use the current date: "
+fi
+
+echo "$NEW_DATE"
+
+# Detect if it is darwin sed
+if sed --version 2>/dev/null | grep -q GNU; then
+    SED_COMMAND="sed -i"
+else
+    SED_COMMAND='sed -i ""'
+fi
+
+MATCH="nightly-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]"
+REPLACE="nightly-$NEW_DATE"
+
+# Find all occurrences of the pattern
+git grep -l "$MATCH" | while read -r file; do
+    # Replace the pattern in each file
+    $SED_COMMAND "s/$MATCH/$REPLACE/g" "$file"
+    echo "Updated $file"
+done
+
+echo "All occurrences of 'nightly-XXXX-XX-XX' have been replaced with 'nightly-$NEW_DATE'"

server_fn/Cargo.toml

@@ -42,7 +42,7 @@ multer = { version = "3.1", optional = true }
 
 ## output encodings
 # serde
-serde_json = "1.0"
+serde_json = { workspace = true }
 serde-lite = { version = "0.5.0", features = ["derive"], optional = true }
 futures = "0.3.31"
 http = { version = "1.1" }
@@ -57,8 +57,8 @@ rmp-serde = { version = "1.3.0", optional = true }
 # client
 gloo-net = { version = "0.6.0", optional = true }
 js-sys = { version = "0.3.74", optional = true }
-wasm-bindgen = { version = "0.2.97", optional = true }
-wasm-bindgen-futures = { version = "0.4.47", optional = true }
+wasm-bindgen = { version = "0.2.100", optional = true }
+wasm-bindgen-futures = { version = "0.4.50", optional = true }
 wasm-streams = { version = "0.4.2", optional = true }
 web-sys = { version = "0.3.72", optional = true, features = [
   "console",

server_fn/server_fn_macro_default/src/lib.rs

@@ -28,7 +28,7 @@ use syn::__private::ToTokens;
 ///
 /// You can any combination of the following named arguments:
 /// - `name`: sets the identifier for the server function’s type, which is a struct created
-///    to hold the arguments (defaults to the function identifier in PascalCase)
+///   to hold the arguments (defaults to the function identifier in PascalCase)
 /// - `prefix`: a prefix at which the server function handler will be mounted (defaults to `/api`)
 /// - `endpoint`: specifies the exact path at which the server function handler will be mounted,
 ///   relative to the prefix (defaults to the function name followed by unique hash)

tachys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tachys"
-version = "0.1.5"
+version = "0.1.7"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"
@@ -24,7 +24,7 @@ async-trait = "0.1.81"
 dyn-clone = "1.0.17"
 once_cell = "1.20"
 paste = "1.0"
-wasm-bindgen = "0.2.97"
+wasm-bindgen = { workspace = true }
 html-escape = "0.2.13"
 js-sys = "0.3.74"
 web-sys = { version = "0.3.72", features = [
@@ -154,7 +154,7 @@ indexmap = "2.6"
 rustc-hash = "2.0"
 futures = "0.3.31"
 parking_lot = "0.12.3"
-itertools = "0.13.0"
+itertools = { workspace = true }
 send_wrapper = "0.6.0"
 linear-map = "1.2"
 sledgehammer_bindgen = { version = "0.6.0", features = [
@@ -165,7 +165,7 @@ tracing = { version = "0.1.41", optional = true }
 
 [dev-dependencies]
 tokio-test = "0.4.4"
-tokio = { version = "1.41", features = ["rt", "macros"] }
+tokio = { version = "1.43", features = ["rt", "macros"] }
 
 [features]
 default = ["testing"]

tachys/src/html/element/elements.rs

@@ -283,7 +283,7 @@ html_elements! {
     /// The `<em>` HTML element marks text that has stress emphasis. The `<em>` element can be nested, with each level of nesting indicating a greater degree of emphasis.
     em HtmlElement [] true,
     /// The `<fieldset>` HTML element is used to group several controls as well as labels (label) within a web form.
-    fieldset HtmlFieldSetElement [] true,
+    fieldset HtmlFieldSetElement [disabled, form, name] true,
     /// The `<figcaption>` HTML element represents a caption or legend describing the rest of the contents of its parent figure element.
     figcaption HtmlElement [] true,
     /// The `<figure>` HTML element represents self-contained content, potentially with an optional caption, which is specified using the figcaption element. The figure, its caption, and its contents are referenced as a single unit.

tachys/src/html/event.rs

@@ -167,6 +167,9 @@ where
             el: &crate::renderer::types::Element,
             cb: Box<dyn FnMut(crate::renderer::types::Event)>,
             name: Cow<'static, str>,
+            // TODO investigate: does passing this as an option
+            // (rather than, say, having a const DELEGATED: bool)
+            // add to binary size?
             delegation_key: Option<Cow<'static, str>>,
         ) -> RemoveEventHandler<crate::renderer::types::Element> {
             match delegation_key {
@@ -201,6 +204,39 @@ where
                 .then(|| self.event.event_delegation_key()),
         )
     }
+
+    /// Attaches the event listener to the element as a listener that is triggered during the capture phase,
+    /// meaning it will fire before any event listeners further down in the DOM.
+    pub fn attach_capture(
+        self,
+        el: &crate::renderer::types::Element,
+    ) -> RemoveEventHandler<crate::renderer::types::Element> {
+        fn attach_inner(
+            el: &crate::renderer::types::Element,
+            cb: Box<dyn FnMut(crate::renderer::types::Event)>,
+            name: Cow<'static, str>,
+        ) -> RemoveEventHandler<crate::renderer::types::Element> {
+            Rndr::add_event_listener_use_capture(el, &name, cb)
+        }
+
+        let mut cb = self.cb.expect("callback removed before attaching").take();
+
+        #[cfg(feature = "tracing")]
+        let span = tracing::Span::current();
+
+        let cb = Box::new(move |ev: crate::renderer::types::Event| {
+            #[cfg(all(debug_assertions, feature = "reactive_graph"))]
+            let _rx_guard =
+                reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
+            #[cfg(feature = "tracing")]
+            let _tracing_guard = span.enter();
+
+            let ev = E::EventType::from(ev);
+            cb.invoke(ev);
+        }) as Box<dyn FnMut(crate::renderer::types::Event)>;
+
+        attach_inner(el, cb, self.event.name())
+    }
 }
 
 impl<E, F> Debug for On<E, F>
@@ -250,13 +286,21 @@ where
         self,
         el: &crate::renderer::types::Element,
     ) -> Self::State {
-        let cleanup = self.attach(el);
+        let cleanup = if E::CAPTURE {
+            self.attach_capture(el)
+        } else {
+            self.attach(el)
+        };
         (el.clone(), Some(cleanup))
     }
 
     #[inline(always)]
     fn build(self, el: &crate::renderer::types::Element) -> Self::State {
-        let cleanup = self.attach(el);
+        let cleanup = if E::CAPTURE {
+            self.attach_capture(el)
+        } else {
+            self.attach(el)
+        };
         (el.clone(), Some(cleanup))
     }
 
@@ -266,7 +310,11 @@ where
         if let Some(prev) = prev_cleanup.take() {
             (prev.into_inner())(el);
         }
-        *prev_cleanup = Some(self.attach(el));
+        *prev_cleanup = Some(if E::CAPTURE {
+            self.attach_capture(el)
+        } else {
+            self.attach(el)
+        });
     }
 
     fn into_cloneable(self) -> Self::Cloneable {
@@ -334,10 +382,13 @@ pub trait EventDescriptor: Clone {
     /// Indicates if this event bubbles. For example, `click` bubbles,
     /// but `focus` does not.
     ///
-    /// If this is true, then the event will be delegated globally,
-    /// otherwise, event listeners will be directly attached to the element.
+    /// If this is true, then the event will be delegated globally if the `delegation`
+    /// feature is enabled. Otherwise, event listeners will be directly attached to the element.
     const BUBBLES: bool;
 
+    /// Indicates if this event should be handled during the capture phase.
+    const CAPTURE: bool = false;
+
     /// The name of the event, such as `click` or `mouseover`.
     fn name(&self) -> Cow<'static, str>;
 
@@ -352,6 +403,32 @@ pub trait EventDescriptor: Clone {
     }
 }
 
+/// A wrapper that tells the framework to handle an event during the capture phase.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Capture<E> {
+    inner: E,
+}
+
+/// Wraps an event to indicate that it should be handled during the capture phase.
+pub fn capture<E>(event: E) -> Capture<E> {
+    Capture { inner: event }
+}
+
+impl<E: EventDescriptor> EventDescriptor for Capture<E> {
+    type EventType = E::EventType;
+
+    const CAPTURE: bool = true;
+    const BUBBLES: bool = E::BUBBLES;
+
+    fn name(&self) -> Cow<'static, str> {
+        self.inner.name()
+    }
+
+    fn event_delegation_key(&self) -> Cow<'static, str> {
+        self.inner.event_delegation_key()
+    }
+}
+
 /// A custom event.
 #[derive(Debug)]
 pub struct Custom<E: FromWasmAbi = web_sys::Event> {

tachys/src/reactive_graph/node_ref.rs

@@ -1,6 +1,7 @@
 use crate::html::{element::ElementType, node_ref::NodeRefContainer};
 use reactive_graph::{
     effect::Effect,
+    graph::untrack,
     signal::{
         guards::{Derefable, ReadGuard},
         RwSignal,
@@ -46,7 +47,10 @@ where
 
         Effect::new(move |_| {
             if let Some(node_ref) = self.get() {
-                f.take().unwrap()(node_ref);
+                let f = f.take().unwrap();
+                untrack(move || {
+                    f(node_ref);
+                });
             }
         });
     }

tachys/src/reactive_graph/suspense.rs

@@ -27,7 +27,7 @@ use reactive_graph::{
 use std::{
     cell::RefCell,
     fmt::Debug,
-    future::{Future, IntoFuture},
+    future::Future,
     mem,
     pin::Pin,
     rc::Rc,
@@ -115,15 +115,11 @@ impl ToAnySubscriber for SuspendSubscriber {
 
 impl<T> Suspend<T> {
     /// Creates a new suspended view.
-    pub fn new<Fut>(fut: Fut) -> Self
-    where
-        Fut: IntoFuture<Output = T>,
-        Fut::IntoFuture: Send + 'static,
-    {
+    pub fn new(fut: impl Future<Output = T> + Send + 'static) -> Self {
         let subscriber = SuspendSubscriber::new();
         let any_subscriber = subscriber.to_any_subscriber();
-        let inner = any_subscriber
-            .with_observer(|| Box::pin(ScopedFuture::new(fut.into_future())));
+        let inner =
+            any_subscriber.with_observer(|| Box::pin(ScopedFuture::new(fut)));
         Self { subscriber, inner }
     }
 }

tachys/src/renderer/dom.rs

@@ -13,7 +13,7 @@ use once_cell::unsync::Lazy;
 use rustc_hash::FxHashSet;
 use std::{any::TypeId, borrow::Cow, cell::RefCell};
 use wasm_bindgen::{intern, prelude::Closure, JsCast, JsValue};
-use web_sys::{Comment, HtmlTemplateElement};
+use web_sys::{AddEventListenerOptions, Comment, HtmlTemplateElement};
 
 /// A [`Renderer`](crate::renderer::Renderer) that uses `web-sys` to manipulate DOM elements in the browser.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -245,6 +245,44 @@ impl Dom {
         })
     }
 
+    pub fn add_event_listener_use_capture(
+        el: &Element,
+        name: &str,
+        cb: Box<dyn FnMut(Event)>,
+    ) -> RemoveEventHandler<Element> {
+        let cb = wasm_bindgen::closure::Closure::wrap(cb);
+        let name = intern(name);
+        let options = AddEventListenerOptions::new();
+        options.set_capture(true);
+        or_debug!(
+            el.add_event_listener_with_callback_and_add_event_listener_options(
+                name,
+                cb.as_ref().unchecked_ref(),
+                &options
+            ),
+            el,
+            "addEventListenerUseCapture"
+        );
+
+        // return the remover
+        RemoveEventHandler::new({
+            let name = name.to_owned();
+            // safe to construct this here, because it will only run in the browser
+            // so it will always be accessed or dropped from the main thread
+            let cb = send_wrapper::SendWrapper::new(cb);
+            move |el: &Element| {
+                or_debug!(
+                    el.remove_event_listener_with_callback(
+                        intern(&name),
+                        cb.as_ref().unchecked_ref()
+                    ),
+                    el,
+                    "removeEventListener"
+                )
+            }
+        })
+    }
+
     pub fn event_target<T>(ev: &Event) -> T
     where
         T: CastFrom<Element>,

tachys/src/view/either.rs

@@ -3,7 +3,9 @@ use super::{
     Render, RenderHtml,
 };
 use crate::{
-    html::attribute::Attribute, hydration::Cursor, ssr::StreamBuilder,
+    html::attribute::{Attribute, NextAttribute},
+    hydration::Cursor,
+    ssr::StreamBuilder,
 };
 use either_of::*;
 use futures::future::join;
@@ -114,6 +116,150 @@ const fn max_usize(vals: &[usize]) -> usize {
     max
 }
 
+#[cfg(not(erase_components))]
+impl<A, B> NextAttribute for Either<A, B>
+where
+    B: NextAttribute,
+    A: NextAttribute,
+{
+    type Output<NewAttr: Attribute> = Either<
+        <A as NextAttribute>::Output<NewAttr>,
+        <B as NextAttribute>::Output<NewAttr>,
+    >;
+
+    fn add_any_attr<NewAttr: Attribute>(
+        self,
+        new_attr: NewAttr,
+    ) -> Self::Output<NewAttr> {
+        match self {
+            Either::Left(left) => Either::Left(left.add_any_attr(new_attr)),
+            Either::Right(right) => Either::Right(right.add_any_attr(new_attr)),
+        }
+    }
+}
+
+#[cfg(erase_components)]
+use crate::html::attribute::any_attribute::{AnyAttribute, IntoAnyAttribute};
+
+#[cfg(erase_components)]
+impl<A, B> NextAttribute for Either<A, B>
+where
+    B: IntoAnyAttribute,
+    A: IntoAnyAttribute,
+{
+    type Output<NewAttr: Attribute> = Vec<AnyAttribute>;
+
+    fn add_any_attr<NewAttr: Attribute>(
+        self,
+        new_attr: NewAttr,
+    ) -> Self::Output<NewAttr> {
+        vec![
+            match self {
+                Either::Left(left) => left.into_any_attr(),
+                Either::Right(right) => right.into_any_attr(),
+            },
+            new_attr.into_any_attr(),
+        ]
+    }
+}
+
+impl<A, B> Attribute for Either<A, B>
+where
+    B: Attribute,
+    A: Attribute,
+{
+    const MIN_LENGTH: usize = max_usize(&[A::MIN_LENGTH, B::MIN_LENGTH]);
+
+    type AsyncOutput = Either<A::AsyncOutput, B::AsyncOutput>;
+    type State = Either<A::State, B::State>;
+    type Cloneable = Either<A::Cloneable, B::Cloneable>;
+    type CloneableOwned = Either<A::CloneableOwned, B::CloneableOwned>;
+
+    fn html_len(&self) -> usize {
+        match self {
+            Either::Left(left) => left.html_len(),
+            Either::Right(right) => right.html_len(),
+        }
+    }
+
+    fn to_html(
+        self,
+        buf: &mut String,
+        class: &mut String,
+        style: &mut String,
+        inner_html: &mut String,
+    ) {
+        match self {
+            Either::Left(left) => left.to_html(buf, class, style, inner_html),
+            Either::Right(right) => {
+                right.to_html(buf, class, style, inner_html)
+            }
+        }
+    }
+
+    fn hydrate<const FROM_SERVER: bool>(
+        self,
+        el: &crate::renderer::types::Element,
+    ) -> Self::State {
+        match self {
+            Either::Left(left) => Either::Left(left.hydrate::<FROM_SERVER>(el)),
+            Either::Right(right) => {
+                Either::Right(right.hydrate::<FROM_SERVER>(el))
+            }
+        }
+    }
+
+    fn build(self, el: &crate::renderer::types::Element) -> Self::State {
+        match self {
+            Either::Left(left) => Either::Left(left.build(el)),
+            Either::Right(right) => Either::Right(right.build(el)),
+        }
+    }
+
+    fn rebuild(self, state: &mut Self::State) {
+        match self {
+            Either::Left(left) => {
+                if let Some(state) = state.as_left_mut() {
+                    left.rebuild(state)
+                }
+            }
+            Either::Right(right) => {
+                if let Some(state) = state.as_right_mut() {
+                    right.rebuild(state)
+                }
+            }
+        }
+    }
+
+    fn into_cloneable(self) -> Self::Cloneable {
+        match self {
+            Either::Left(left) => Either::Left(left.into_cloneable()),
+            Either::Right(right) => Either::Right(right.into_cloneable()),
+        }
+    }
+
+    fn into_cloneable_owned(self) -> Self::CloneableOwned {
+        match self {
+            Either::Left(left) => Either::Left(left.into_cloneable_owned()),
+            Either::Right(right) => Either::Right(right.into_cloneable_owned()),
+        }
+    }
+
+    fn dry_resolve(&mut self) {
+        match self {
+            Either::Left(left) => left.dry_resolve(),
+            Either::Right(right) => right.dry_resolve(),
+        }
+    }
+
+    async fn resolve(self) -> Self::AsyncOutput {
+        match self {
+            Either::Left(left) => Either::Left(left.resolve().await),
+            Either::Right(right) => Either::Right(right.resolve().await),
+        }
+    }
+}
+
 impl<A, B> RenderHtml for Either<A, B>
 where
     A: RenderHtml,

tachys/src/view/iterators.rs

@@ -290,6 +290,7 @@ where
             child.to_html_with_buf(buf, position, escape, mark_branches);
         }
         buf.push_str("<!>");
+        *position = Position::NextChild;
     }
 
     fn to_html_async_with_buf<const OUT_OF_ORDER: bool>(
@@ -319,6 +320,7 @@ where
             );
         }
         buf.push_sync("<!>");
+        *position = Position::NextChild;
     }
 
     fn hydrate<const FROM_SERVER: bool>(
@@ -332,6 +334,7 @@ where
             .collect();
 
         let marker = cursor.next_placeholder(position);
+        position.set(Position::NextChild);
 
         VecState { states, marker }
     }

tachys/src/view/keyed.rs

@@ -276,6 +276,7 @@ where
             rendered_items.push(Some((set_index, item)));
         }
         let marker = cursor.next_placeholder(position);
+        position.set(Position::NextChild);
         KeyedState {
             parent: Some(parent),
             marker,

tachys/src/view/static_types.rs

@@ -3,7 +3,12 @@ use super::{
     RenderHtml, ToTemplate,
 };
 use crate::{
-    html::attribute::{Attribute, AttributeKey, AttributeValue, NextAttribute},
+    html::attribute::{
+        maybe_next_attr_erasure_macros::{
+            next_attr_combine, next_attr_output_type,
+        },
+        Attribute, AttributeKey, AttributeValue, NextAttribute,
+    },
     hydration::Cursor,
     renderer::{CastFrom, Rndr},
 };
@@ -111,13 +116,13 @@ impl<K, const V: &'static str> NextAttribute for StaticAttr<K, V>
 where
     K: AttributeKey,
 {
-    type Output<NewAttr: Attribute> = (Self, NewAttr);
+    next_attr_output_type!(Self, NewAttr);
 
     fn add_any_attr<NewAttr: Attribute>(
         self,
         new_attr: NewAttr,
     ) -> Self::Output<NewAttr> {
-        (StaticAttr::<K, V> { ty: PhantomData }, new_attr)
+        next_attr_combine!(StaticAttr::<K, V> { ty: PhantomData }, new_attr)
     }
 }
 

tachys/src/view/tuples.rs

@@ -45,7 +45,9 @@ impl RenderHtml for () {
         cursor: &Cursor,
         position: &PositionState,
     ) -> Self::State {
-        cursor.next_placeholder(position)
+        let marker = cursor.next_placeholder(position);
+        position.set(Position::NextChild);
+        marker
     }
 
     async fn resolve(self) -> Self::AsyncOutput {}